Message.java

  1. /*******************************************************************************

  3.  * Original from https://github.com/cose-wg/COSE-JAVA Commit 1a20373
  4.  *
  5.  * Copyright (c) 2016, Jim Schaad
  6.  * Copyright (c) 2018, Ludwig Seitz, RISE SICS
  7.  * Copyright (c) 2018, Rikard Höglund, RISE SICS
  8.  * All rights reserved.

  10.  * Redistribution and use in source and binary forms, with or without
  11.  * modification, are permitted provided that the following conditions are met:

  13.  * Redistributions of source code must retain the above copyright notice,
  14.  * this list of conditions and the following disclaimer.

  16.  * Redistributions in binary form must reproduce the above copyright notice,
  17.  * this list of conditions and the following disclaimer in the documentation
  18.  * and/or other materials provided with the distribution.

  20.  * Neither the name of COSE-JAVA nor the names of its
  21.  * contributors may be used to endorse or promote products derived from
  22.  * this software without specific prior written permission.

  24.  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  25.  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  27.  * PURPOSE ARE
  28.  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  29.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  30.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  31.  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  32.  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  33.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
  34.  * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35.  * 
  36.  * Contributors:
  37.  *    Achim Kraus (Bosch Software Innovations GmbH) - update to cbor 4.0.0
  38.  *                                                    align with cose 1.0
  39.  *                                                    commit 629912b94ea80c4c6
  40.  ******************************************************************************/
  41. package org.eclipse.californium.cose;

  43. import com.upokecenter.cbor.CBORObject;
  44. import com.upokecenter.cbor.CBORType;

  46. import java.util.ArrayList;
  47. import java.util.List;

  49. import org.eclipse.californium.elements.util.StandardCharsets;

  51. /**
  52.  * The Message class provides a common class that all of the COSE message classes
  53.  * inherit from.  It provides the function used for decoding all of the known
  54.  * messages.
  55.  * 
  56.  * @author jimsch
  57.  */
  58. public abstract class Message extends Attribute {
  59.     /**
  60.      * Is the tag identifying the message emitted?
  61.      */
  62.     protected boolean emitTag = true;
  63.     
  64.     /**
  65.      * Is the content emitted as part of the message?
  66.      */
  67.     protected boolean emitContent = true;
  68.     
  69.     /**
  70.      * What message tag identifies this message?
  71.     */
  72.     protected MessageTag messageTag = MessageTag.Unknown;
  73.     
  74.     /**
  75.      * What is the plain text content of the message.
  76.      */
  77.     protected byte[] rgbContent = null;
  78.   
  79.     /**
  80.      * Decode a COSE message object.  This function assumes that the message
  81.      * has a leading CBOR tag to identify the message type.  If this is not
  82.      * true then use {#link DecodeFromBytes(byte[], MessageTag)}.
  83.      * 
  84.      * @param rgbData byte stream to be decoded
  85.      * @return the decoded message object
  86.      * @throws CoseException on a decode failure
  87.      */
  88.     public static Message DecodeFromBytes(byte[] rgbData) throws CoseException {
  89.         return DecodeFromBytes(rgbData, MessageTag.Unknown);
  90.     }
  91.     
  92.     /**
  93.      * Decode a COSE message object. Use a value of {@code MessageTag.Unknown}
  94.      * to decode a generic structure with tagging.  Use a specific value if
  95.      * the tagging is absent or if a known structure is passed in.
  96.      * 
  97.      * @param rgbData byte stream to be decoded
  98.      * @param defaultTag assumed message type to be decoded
  99.      * @return the decoded message object
  100.      * @throws CoseException on a decode failure.
  101.      */
  102.     public static Message DecodeFromBytes(byte[] rgbData, MessageTag defaultTag) throws CoseException {
  103.         CBORObject messageObject = CBORObject.DecodeFromBytes(rgbData);
  104.         
  105.         if (messageObject.getType() != CBORType.Array)  throw new CoseException("Message is not a COSE security Message");
  106.         
  107.         if (messageObject.isTagged()) {
  108.             if (messageObject.getTagCount() != 1) throw new CoseException("Malformed message - too many tags");
  109.             
  110.             if (defaultTag == MessageTag.Unknown) {
  111.                 defaultTag = MessageTag.FromInt(messageObject.getMostInnerTag().ToInt32Unchecked());
  112.             }
  113.             else if (defaultTag != MessageTag.FromInt(messageObject.getMostInnerTag().ToInt32Unchecked())) {
  114.                 throw new CoseException("Passed in tag does not match actual tag");
  115.             }
  116.         }
  117.         
  118.         Message msg;
  119.         
  120.         switch (defaultTag) {
  121.             case Unknown: // Unknown
  122.                 throw new CoseException("Message was not tagged and no default tagging option given");
  123.         
  124.             case Encrypt:
  125.             msg = new EncryptMessage();
  126.             break;

  128.         case Encrypt0:
  129.             msg = new Encrypt0Message();
  130.             break;

  132.             case MAC: 
  133.             msg = new MACMessage();
  134.             break;

  136.         case MAC0:
  137.             msg = new MAC0Message();
  138.             break;

  140.             case Sign1:
  141.             msg = new Sign1Message();
  142.             break;

  144.             case Sign:
  145.             msg = new SignMessage();
  146.             break;
  147.                 
  148.             default:
  149.                 throw new CoseException("Message is not recognized as a COSE security Object");
  150.         }
  151.     
  152.         msg.DecodeFromCBORObject(messageObject);
  153.         return msg;
  154.         
  155.     }

  157.     /**
  158.      * Encode the message to a byte array.  This function will force cryptographic operations to be executed as needed.
  159.      * 
  160.      * @return byte encoded object 
  161.      * @throws CoseException Internal COSE Exception
  162.      */
  163.     public byte[] EncodeToBytes() throws CoseException {
  164.         return EncodeToCBORObject().EncodeToBytes();
  165.     }

  167.     /**
  168.      * Given a CBOR tree, parse the message.  This is an abstract function that is implemented for each different supported COSE message. 
  169.      * 
  170.      * @param messageObject CBORObject to be converted to a message.
  171.      * @throws CoseException Internal COSE Exception
  172.      */
  173.     
  174.     protected abstract void DecodeFromCBORObject(CBORObject messageObject) throws CoseException;
  175.     
  176.     /**
  177.      * Encode the COSE message object to a CBORObject tree.  This function call will force cryptographic operations to be executed as needed.
  178.      * This is an internal function, as such it does not add the tag on the front and is implemented on a per message object.
  179.      * 
  180.      * @return CBORObject representing the message.
  181.      * @throws CoseException Internal COSE Exception
  182.      */
  183.     protected abstract CBORObject EncodeCBORObject() throws CoseException;
  184.     
  185.     /**
  186.      * Encode the COSE message object to a CBORObject tree.  This function call will force cryptographic operations to be executed as needed.
  187.      * 
  188.      * @return CBORObject representing the message.
  189.      * @throws CoseException Internal COSE Exception
  190.      */
  191.     public CBORObject EncodeToCBORObject() throws CoseException {
  192.         CBORObject obj;
  193.         
  194.         obj = EncodeCBORObject();
  195.         
  196.         if (emitTag) {
  197.             obj = CBORObject.FromObjectAndTag(obj, messageTag.value);
  198.         }
  199.         
  200.         return obj;
  201.     }

  203.     /**
  204.      * Return the content bytes of the message
  205.      * 
  206.      * @return bytes of the content
  207.      */
  208.     public byte[] GetContent() {
  209.         return rgbContent;
  210.     }
  211.     
  212.     /**
  213.      * Does the message current have content?
  214.      * 
  215.      * @return true if it has content 
  216.      */
  217.     public boolean HasContent() {
  218.         return rgbContent != null;
  219.     }
  220.     
  221.     /**
  222.      * Set the content bytes of the message.  If the message was transmitted with 
  223.      * detached content, this must be called before doing cryptographic processing on the message.
  224.      * 
  225.      * @param rgbData bytes to set as the content
  226.      */
  227.     public void SetContent(byte[] rgbData) {
  228.         rgbContent = rgbData;
  229.     }
  230.     
  231.     /**
  232.      * Set the content bytes as a text string.  The string will be encoded using UTF8 into a byte string.
  233.      * 
  234.      * @param strData string to set as the content
  235.      */
  236.     public void SetContent(String strData) {
  237.         rgbContent = strData.getBytes(StandardCharsets.UTF_8);
  238.     }

  240.     List<CounterSign> counterSignList = new ArrayList<CounterSign>();
  241.     CounterSign1 counterSign1;

  243.     public void addCountersignature(CounterSign countersignature) {
  244.         counterSignList.add(countersignature);
  245.     }

  247.     public List<CounterSign> getCountersignerList() {
  248.         return counterSignList;
  249.     }

  251.     public CounterSign1 getCountersign1() {
  252.         return counterSign1;
  253.     }

  255.     public void setCountersign1(CounterSign1 value) {
  256.         counterSign1 = value;
  257.     }

  259.     protected void ProcessCounterSignatures() throws CoseException {
  260.         if (!counterSignList.isEmpty()) {
  261.             if (counterSignList.size() == 1) {
  262.                 counterSignList.get(0).sign(rgbProtected, rgbContent);
  263.                 addAttribute(HeaderKeys.CounterSignature, counterSignList.get(0).EncodeToCBORObject(),
  264.                         Attribute.UNPROTECTED);
  265.             } else {
  266.                 CBORObject list = CBORObject.NewArray();
  267.                 for (CounterSign sig : counterSignList) {
  268.                     sig.sign(rgbProtected, rgbContent);
  269.                     list.Add(sig.EncodeToCBORObject());
  270.                 }
  271.                 addAttribute(HeaderKeys.CounterSignature, list, Attribute.UNPROTECTED);
  272.             }
  273.         }

  275.         if (counterSign1 != null) {
  276.             counterSign1.sign(rgbProtected, rgbContent);
  277.             addAttribute(HeaderKeys.CounterSignature0, counterSign1.EncodeToCBORObject(), Attribute.UNPROTECTED);
  278.         }
  279.     }

  281.     public boolean validate(CounterSign1 countersignature) throws CoseException {
  282.         return countersignature.validate(rgbProtected, rgbContent);
  283.     }

  285.     public boolean validate(CounterSign countersignature) throws CoseException {
  286.         return countersignature.validate(rgbProtected, rgbContent);
  287.     }
  288. }
Created with JaCoCo 0.8.6.202009150832