cose/
keys.rs

1//! Module to encode/decode cose-keys/cose-keySets.
2//!
3//! # cose-keySet example
4//! ```
5//! use cose::keys;
6//! use cose::algs;
7//! use hex;
8//!
9//! fn main() {
10//!     let mut key = keys::CoseKey::new();
11//!     key.kty(keys::EC2);
12//!     key.alg(algs::ES256);
13//!     key.crv(keys::P_256);
14//!     key.d(hex::decode("57c92077664146e876760c9520d054aa93c3afb04e306705db6090308507b4d3").unwrap());
15//!     key.key_ops(vec![keys::KEY_OPS_SIGN]);
16//!
17//!     key.encode().unwrap();
18//!
19//!     let mut decode_key = keys::CoseKey::new();
20//!     decode_key.bytes = key.bytes;
21//!
22//!     decode_key.decode().unwrap();
23//!
24//!     assert_eq!(decode_key.d, key.d);
25//!     assert_eq!(decode_key.kty, key.kty);
26//!     assert_eq!(decode_key.crv, key.crv);
27//!     assert_eq!(decode_key.alg, key.alg);
28//!
29//!     let mut key_set = keys::CoseKeySet::new();
30//!     key_set.add_key(&decode_key);
31//!     key_set.encode();
32//!
33//!     let mut decode_key_set = keys::CoseKeySet::new();
34//!     decode_key_set.bytes = key_set.bytes;
35//!     decode_key_set.decode();
36//!
37//!     assert_eq!(decode_key_set.cose_keys[0].d, key.d);
38//!     assert_eq!(decode_key_set.cose_keys[0].kty, key.kty);
39//!     assert_eq!(decode_key_set.cose_keys[0].crv, key.crv);
40//!     assert_eq!(decode_key_set.cose_keys[0].alg, key.alg);
41//! }
42//! ```
43
44use crate::common;
45use crate::errors::{CoseError, CoseField, CoseResult, CoseResultWithRet};
46use cbor::{types::Type, Config, Decoder, Encoder};
47use openssl::bn::BigNum;
48use openssl::rsa::Rsa;
49use std::io::Cursor;
50use std::str::from_utf8;
51
52pub(crate) const ECDH_KTY: [i32; 2] = [OKP, EC2];
53
54//COMMON PARAMETERS
55pub const D: i32 = -4;
56pub const Y: i32 = -3;
57pub const X: i32 = -2;
58pub const CRV_K: i32 = -1;
59pub const KTY: i32 = 1;
60pub const KID: i32 = 2;
61pub const ALG: i32 = 3;
62pub const KEY_OPS: i32 = 4;
63pub const BASE_IV: i32 = 5;
64
65//RSA PARAMETERS
66pub const N: i32 = -1;
67pub const E: i32 = -2;
68pub const RSA_D: i32 = -3;
69pub const P: i32 = -4;
70pub const Q: i32 = -5;
71pub const DP: i32 = -6;
72pub const DQ: i32 = -7;
73pub const QINV: i32 = -8;
74pub const OTHER: i32 = -9;
75pub const RI: i32 = -10;
76pub const DI: i32 = -11;
77pub const TI: i32 = -12;
78
79//KEY TYPES
80pub const OKP: i32 = 1;
81pub const EC2: i32 = 2;
82pub const RSA: i32 = 3;
83pub const SYMMETRIC: i32 = 4;
84pub const RESERVED: i32 = 0;
85pub(crate) const KTY_ALL: [i32; 5] = [RESERVED, OKP, EC2, RSA, SYMMETRIC];
86pub(crate) const KTY_NAMES: [&str; 5] = ["Reserved", "OKP", "EC2", "RSA", "Symmetric"];
87
88//KEY OPERATIONS
89pub const KEY_OPS_SIGN: i32 = 1;
90pub const KEY_OPS_VERIFY: i32 = 2;
91pub const KEY_OPS_ENCRYPT: i32 = 3;
92pub const KEY_OPS_DECRYPT: i32 = 4;
93pub const KEY_OPS_WRAP: i32 = 5;
94pub const KEY_OPS_UNWRAP: i32 = 6;
95pub const KEY_OPS_DERIVE: i32 = 7;
96pub const KEY_OPS_DERIVE_BITS: i32 = 8;
97pub const KEY_OPS_MAC: i32 = 9;
98pub const KEY_OPS_MAC_VERIFY: i32 = 10;
99pub(crate) const KEY_OPS_ALL: [i32; 10] = [
100    KEY_OPS_SIGN,
101    KEY_OPS_VERIFY,
102    KEY_OPS_ENCRYPT,
103    KEY_OPS_DECRYPT,
104    KEY_OPS_WRAP,
105    KEY_OPS_UNWRAP,
106    KEY_OPS_DERIVE,
107    KEY_OPS_DERIVE_BITS,
108    KEY_OPS_MAC,
109    KEY_OPS_MAC_VERIFY,
110];
111pub(crate) const KEY_OPS_NAMES: [&str; 10] = [
112    "sign",
113    "verify",
114    "encrypt",
115    "decrypt",
116    "wrap key",
117    "unwrap key",
118    "derive key",
119    "derive bits",
120    "MAC create",
121    "MAC verify",
122];
123
124//CURVES
125pub const P_256: i32 = 1;
126pub const SECP256K1: i32 = 8;
127pub const P_384: i32 = 2;
128pub const P_521: i32 = 3;
129pub const X25519: i32 = 4;
130pub const X448: i32 = 5;
131pub const ED25519: i32 = 6;
132pub const ED448: i32 = 7;
133pub(crate) const CURVES_ALL: [i32; 8] =
134    [P_256, P_384, P_521, X25519, X448, ED25519, ED448, SECP256K1];
135pub(crate) const EC2_CRVS: [i32; 4] = [P_256, P_384, P_521, SECP256K1];
136pub(crate) const CURVES_NAMES: [&str; 8] = [
137    "P-256",
138    "P-384",
139    "P-521",
140    "X25519",
141    "X448",
142    "Ed25519",
143    "Ed448",
144    "secp256k1",
145];
146
147/// cose-key structure.
148#[derive(Clone)]
149pub struct CoseKey {
150    /// cose-key encoded bytes.
151    pub bytes: Vec<u8>,
152    used: Vec<i32>,
153    /// Key Type.
154    pub kty: Option<i32>,
155    /// Base Initialization Vector.
156    pub base_iv: Option<Vec<u8>>,
157    /// List of Key Operations.
158    pub key_ops: Vec<i32>,
159    /// COSE Algorithm.
160    pub alg: Option<i32>,
161    /// Public Key X parameter for OKP/EC2 Keys.
162    pub x: Option<Vec<u8>>,
163    /// Public Key Y parameter for EC2 Keys.
164    pub y: Option<Vec<u8>>,
165    /// Public Key Y parity for EC2 Keys.
166    pub y_parity: Option<bool>,
167    /// Private Key D parameter for OKP/EC2 Keys.
168    pub d: Option<Vec<u8>>,
169    /// Key value for Symmetric Keys.
170    pub k: Option<Vec<u8>>,
171    /// Key ID.
172    pub kid: Option<Vec<u8>>,
173    /// COSE curve for OKP/EC2 keys.
174    pub crv: Option<i32>,
175    pub n: Option<Vec<u8>>,
176    pub e: Option<Vec<u8>>,
177    pub rsa_d: Option<Vec<u8>>,
178    pub p: Option<Vec<u8>>,
179    pub q: Option<Vec<u8>>,
180    pub dp: Option<Vec<u8>>,
181    pub dq: Option<Vec<u8>>,
182    pub qinv: Option<Vec<u8>>,
183    pub other: Option<Vec<Vec<Vec<u8>>>>,
184}
185
186impl CoseKey {
187    /// Creates an empty CoseKey structure
188    pub fn new() -> CoseKey {
189        CoseKey {
190            bytes: Vec::new(),
191            used: Vec::new(),
192            key_ops: Vec::new(),
193            base_iv: None,
194            kty: None,
195            alg: None,
196            x: None,
197            y: None,
198            y_parity: None,
199            d: None,
200            k: None,
201            kid: None,
202            crv: None,
203            n: None,
204            e: None,
205            rsa_d: None,
206            p: None,
207            q: None,
208            dp: None,
209            dq: None,
210            qinv: None,
211            other: None,
212        }
213    }
214
215    fn reg_label(&mut self, label: i32) {
216        self.used.retain(|&x| x != label);
217        self.used.push(label);
218    }
219
220    pub(crate) fn remove_label(&mut self, label: i32) {
221        self.used.retain(|&x| x != label);
222    }
223
224    /// Adds Key Type to the cose-key.
225    pub fn kty(&mut self, kty: i32) {
226        self.reg_label(KTY);
227        self.kty = Some(kty);
228    }
229    /// Adds Key ID to the cose-key.
230    pub fn unset_alg(&mut self) {
231        self.remove_label(ALG);
232        self.alg = None;
233    }
234
235    /// Adds Key ID to the cose-key.
236    pub fn kid(&mut self, kid: Vec<u8>) {
237        self.reg_label(KID);
238        self.kid = Some(kid);
239    }
240
241    /// Adds Algorithm to cose-key.
242    pub fn alg(&mut self, alg: i32) {
243        self.reg_label(ALG);
244        self.alg = Some(alg);
245    }
246
247    /// Adds Key Operations to the cose-key.
248    pub fn key_ops(&mut self, key_ops: Vec<i32>) {
249        self.reg_label(KEY_OPS);
250        self.key_ops = key_ops;
251    }
252
253    /// Adds Base Initialization Vector to the cose-key.
254    pub fn base_iv(&mut self, base_iv: Vec<u8>) {
255        self.reg_label(BASE_IV);
256        self.base_iv = Some(base_iv);
257    }
258
259    /// Adds Curve to the cose-key.
260    pub fn crv(&mut self, crv: i32) {
261        self.reg_label(CRV_K);
262        self.crv = Some(crv);
263    }
264
265    /// Adds X parameter to the cose-key.
266    pub fn x(&mut self, x: Vec<u8>) {
267        self.reg_label(X);
268        self.x = Some(x);
269    }
270
271    /// Adds Y parameter to the cose-key.
272    pub fn y(&mut self, y: Vec<u8>) {
273        self.y_parity = None;
274        self.reg_label(Y);
275        self.y = Some(y);
276    }
277
278    /// Adds Y parity to the cose-key.
279    pub fn y_parity(&mut self, parity: bool) {
280        self.y = None;
281        self.reg_label(Y);
282        self.y_parity = Some(parity);
283    }
284
285    /// Adds D parameter to the cose-key.
286    pub fn d(&mut self, d: Vec<u8>) {
287        self.reg_label(D);
288        self.d = Some(d);
289    }
290
291    /// Adds Symmetric Key value to the cose-key.
292    pub fn k(&mut self, k: Vec<u8>) {
293        self.reg_label(CRV_K);
294        self.k = Some(k);
295    }
296    pub fn n(&mut self, n: Vec<u8>) {
297        self.reg_label(N);
298        self.n = Some(n);
299    }
300    pub fn e(&mut self, e: Vec<u8>) {
301        self.reg_label(E);
302        self.e = Some(e);
303    }
304    pub fn rsa_d(&mut self, rsa_d: Vec<u8>) {
305        self.reg_label(RSA_D);
306        self.rsa_d = Some(rsa_d);
307    }
308    pub fn p(&mut self, p: Vec<u8>) {
309        self.reg_label(P);
310        self.p = Some(p);
311    }
312    pub fn q(&mut self, q: Vec<u8>) {
313        self.reg_label(Q);
314        self.q = Some(q);
315    }
316    pub fn dp(&mut self, dp: Vec<u8>) {
317        self.reg_label(DP);
318        self.dp = Some(dp);
319    }
320    pub fn dq(&mut self, dq: Vec<u8>) {
321        self.reg_label(DQ);
322        self.dq = Some(dq);
323    }
324    pub fn qinv(&mut self, qinv: Vec<u8>) {
325        self.reg_label(QINV);
326        self.qinv = Some(qinv);
327    }
328    pub fn other(&mut self, other: Vec<Vec<Vec<u8>>>) {
329        self.reg_label(OTHER);
330        self.other = Some(other);
331    }
332
333    pub(crate) fn verify_curve(&self) -> CoseResult {
334        let kty = self.kty.ok_or(CoseError::Missing(CoseField::Kty))?;
335        if kty == SYMMETRIC || kty == RSA {
336            return Ok(());
337        }
338        let crv = self.crv.ok_or(CoseError::Missing(CoseField::Crv))?;
339
340        if kty == OKP && [ED25519, ED448, X25519, X448].contains(&crv) {
341            Ok(())
342        } else if kty == EC2 && EC2_CRVS.contains(&crv) {
343            Ok(())
344        } else {
345            Err(CoseError::Invalid(CoseField::Crv))
346        }
347    }
348
349    pub(crate) fn verify_kty(&self) -> CoseResult {
350        if !KTY_ALL.contains(&self.kty.ok_or(CoseError::Missing(CoseField::Kty))?) {
351            return Err(CoseError::Invalid(CoseField::Kty));
352        }
353        self.verify_curve()?;
354        Ok(())
355    }
356
357    /// Method to encode the cose-Key.
358    pub fn encode(&mut self) -> CoseResult {
359        let mut e = Encoder::new(Vec::new());
360        if self.alg != None {
361            self.verify_kty()?;
362        } else {
363            self.verify_curve()?;
364        }
365        self.encode_key(&mut e)?;
366        self.bytes = e.into_writer().to_vec();
367        Ok(())
368    }
369
370    pub(crate) fn verify_key_ops(&self) -> CoseResult {
371        let kty = self.kty.ok_or(CoseError::Missing(CoseField::Kty))?;
372        if !self.key_ops.is_empty() {
373            match kty {
374                EC2 | OKP => {
375                    if self.key_ops.contains(&KEY_OPS_VERIFY) {
376                        if self.x == None {
377                            return Err(CoseError::Missing(CoseField::X));
378                        } else if kty == EC2 && self.y.is_none() && self.y_parity.is_none() {
379                            return Err(CoseError::Missing(CoseField::Y));
380                        } else if self.crv == None {
381                            return Err(CoseError::Missing(CoseField::Crv));
382                        }
383                    }
384                    if self.key_ops.contains(&KEY_OPS_SIGN)
385                        || self.key_ops.contains(&KEY_OPS_DERIVE)
386                        || self.key_ops.contains(&KEY_OPS_DERIVE_BITS)
387                    {
388                        if self.d == None {
389                            return Err(CoseError::Missing(CoseField::D));
390                        } else if self.crv == None {
391                            return Err(CoseError::Missing(CoseField::Crv));
392                        }
393                    }
394                }
395                SYMMETRIC => {
396                    if self.key_ops.contains(&KEY_OPS_ENCRYPT)
397                        || self.key_ops.contains(&KEY_OPS_MAC_VERIFY)
398                        || self.key_ops.contains(&KEY_OPS_MAC)
399                        || self.key_ops.contains(&KEY_OPS_DECRYPT)
400                        || self.key_ops.contains(&KEY_OPS_UNWRAP)
401                        || self.key_ops.contains(&KEY_OPS_WRAP)
402                    {
403                        if self.x != None {
404                            return Err(CoseError::Missing(CoseField::X));
405                        } else if self.y.is_some() || self.y_parity.is_some() {
406                            return Err(CoseError::Missing(CoseField::Y));
407                        } else if self.d != None {
408                            return Err(CoseError::Missing(CoseField::D));
409                        }
410                        if self.k == None {
411                            return Err(CoseError::Missing(CoseField::K));
412                        }
413                    }
414                }
415                RSA => {
416                    if self.key_ops.contains(&KEY_OPS_VERIFY) {
417                        if self.n.is_none() {
418                            return Err(CoseError::Missing(CoseField::N));
419                        } else if self.e.is_none() {
420                            return Err(CoseError::Missing(CoseField::E));
421                        } else if [
422                            &self.rsa_d,
423                            &self.p,
424                            &self.q,
425                            &self.dp,
426                            &self.dq,
427                            &self.qinv,
428                        ]
429                        .iter()
430                        .any(|v| v.is_some())
431                            || self.other.is_some()
432                        {
433                            return Err(CoseError::Missing(CoseField::E));
434                        }
435                    }
436                    if self.key_ops.contains(&KEY_OPS_SIGN)
437                        || self.key_ops.contains(&KEY_OPS_DERIVE)
438                        || self.key_ops.contains(&KEY_OPS_DERIVE_BITS)
439                    {
440                        if [
441                            &self.n,
442                            &self.e,
443                            &self.rsa_d,
444                            &self.p,
445                            &self.q,
446                            &self.dp,
447                            &self.dq,
448                            &self.qinv,
449                        ]
450                        .iter()
451                        .any(|v| v.is_none())
452                        {
453                            return Err(CoseError::Missing(CoseField::E));
454                        }
455                        if self.other.is_some() {
456                            for primes in self.other.as_ref().unwrap() {
457                                if primes.len() != 3 {
458                                    return Err(CoseError::Invalid(CoseField::Other));
459                                }
460                            }
461                        }
462                    }
463                }
464                _ => {
465                    return Err(CoseError::Invalid(CoseField::Kty));
466                }
467            }
468        }
469        return Ok(());
470    }
471
472    pub(crate) fn encode_key(&self, e: &mut Encoder<Vec<u8>>) -> CoseResult {
473        let kty = self.kty.ok_or(CoseError::Missing(CoseField::Kty))?;
474        self.verify_key_ops()?;
475        let key_ops_len = self.key_ops.len();
476        if key_ops_len > 0 {
477            if kty == EC2 || kty == OKP {
478                if self.key_ops.contains(&KEY_OPS_VERIFY)
479                    || self.key_ops.contains(&KEY_OPS_DERIVE)
480                    || self.key_ops.contains(&KEY_OPS_DERIVE_BITS)
481                {
482                    if !self.x.is_some() {
483                        return Err(CoseError::Missing(CoseField::X));
484                    } else if !self.crv.is_some() {
485                        return Err(CoseError::Missing(CoseField::Crv));
486                    }
487                }
488                if self.key_ops.contains(&KEY_OPS_SIGN) {
489                    if !self.d.is_some() {
490                        return Err(CoseError::Missing(CoseField::D));
491                    } else if !self.crv.is_some() {
492                        return Err(CoseError::Missing(CoseField::Crv));
493                    }
494                }
495            } else if kty == SYMMETRIC {
496                if self.key_ops.contains(&KEY_OPS_ENCRYPT)
497                    || self.key_ops.contains(&KEY_OPS_MAC_VERIFY)
498                    || self.key_ops.contains(&KEY_OPS_MAC)
499                    || self.key_ops.contains(&KEY_OPS_DECRYPT)
500                    || self.key_ops.contains(&KEY_OPS_UNWRAP)
501                    || self.key_ops.contains(&KEY_OPS_WRAP)
502                {
503                    if self.x.is_some() {
504                        return Err(CoseError::Invalid(CoseField::X));
505                    } else if self.y.is_some() {
506                        return Err(CoseError::Invalid(CoseField::Y));
507                    } else if self.d.is_some() {
508                        return Err(CoseError::Invalid(CoseField::D));
509                    }
510                    if !self.k.is_some() {
511                        return Err(CoseError::Missing(CoseField::K));
512                    }
513                }
514            }
515        }
516        e.object(self.used.len())?;
517        for i in &self.used {
518            e.i32(*i)?;
519
520            match *i {
521                KTY => {
522                    e.i32(kty)?;
523                }
524                KEY_OPS => {
525                    e.array(self.key_ops.len())?;
526                    for x in &self.key_ops {
527                        e.i32(*x)?;
528                    }
529                }
530                CRV_K => {
531                    if self.crv != None {
532                        e.i32(self.crv.ok_or(CoseError::Missing(CoseField::Crv))?)?;
533                    } else if self.kty.ok_or(CoseError::Missing(CoseField::Kty))? == RSA {
534                        e.bytes(&self.n.as_ref().ok_or(CoseError::Missing(CoseField::N))?)?;
535                    } else {
536                        e.bytes(&self.k.as_ref().ok_or(CoseError::Missing(CoseField::K))?)?;
537                    }
538                }
539                KID => {
540                    e.bytes(
541                        &self
542                            .kid
543                            .as_ref()
544                            .ok_or(CoseError::Missing(CoseField::Kid))?,
545                    )?;
546                }
547                ALG => {
548                    e.i32(self.alg.ok_or(CoseError::Missing(CoseField::Alg))?)?;
549                }
550                BASE_IV => {
551                    e.bytes(
552                        &self
553                            .base_iv
554                            .as_ref()
555                            .ok_or(CoseError::Missing(CoseField::BaseIv))?,
556                    )?;
557                }
558                X => {
559                    if self.kty.ok_or(CoseError::Missing(CoseField::Kty))? == RSA {
560                        e.bytes(&self.e.as_ref().ok_or(CoseError::Missing(CoseField::E))?)?;
561                    } else {
562                        e.bytes(&self.x.as_ref().ok_or(CoseError::Missing(CoseField::X))?)?;
563                    }
564                }
565                Y => {
566                    if self.kty.ok_or(CoseError::Missing(CoseField::Kty))? == RSA {
567                        e.bytes(
568                            &self
569                                .rsa_d
570                                .as_ref()
571                                .ok_or(CoseError::Missing(CoseField::RsaD))?,
572                        )?;
573                    } else {
574                        if self.y_parity.is_none() {
575                            e.bytes(&self.y.as_ref().ok_or(CoseError::Missing(CoseField::Y))?)?;
576                        } else {
577                            e.bool(self.y_parity.ok_or(CoseError::Missing(CoseField::Y))?)?;
578                        }
579                    }
580                }
581                D => {
582                    if self.kty.ok_or(CoseError::Missing(CoseField::Kty))? == RSA {
583                        e.bytes(&self.p.as_ref().ok_or(CoseError::Missing(CoseField::P))?)?;
584                    } else {
585                        e.bytes(&self.d.as_ref().ok_or(CoseError::Missing(CoseField::D))?)?;
586                    }
587                }
588                Q => e.bytes(&self.q.as_ref().ok_or(CoseError::Missing(CoseField::Q))?)?,
589                DP => e.bytes(&self.dp.as_ref().ok_or(CoseError::Missing(CoseField::DP))?)?,
590                DQ => e.bytes(&self.dq.as_ref().ok_or(CoseError::Missing(CoseField::DQ))?)?,
591                QINV => e.bytes(
592                    &self
593                        .qinv
594                        .as_ref()
595                        .ok_or(CoseError::Missing(CoseField::QInv))?,
596                )?,
597                OTHER => {
598                    let other = self
599                        .other
600                        .as_ref()
601                        .ok_or(CoseError::Missing(CoseField::Other))?;
602                    e.array(other.len())?;
603                    for v in other {
604                        e.object(3)?;
605                        e.i32(RI)?;
606                        e.bytes(&v[0])?;
607                        e.i32(DI)?;
608                        e.bytes(&v[1])?;
609                        e.i32(TI)?;
610                        e.bytes(&v[2])?;
611                    }
612                }
613                _ => {
614                    return Err(CoseError::InvalidLabel(*i));
615                }
616            }
617        }
618        Ok(())
619    }
620
621    /// Method to decode a cose-Key.
622    pub fn decode(&mut self) -> CoseResult {
623        let input = Cursor::new(self.bytes.clone());
624        let mut d = Decoder::new(Config::default(), input);
625        self.decode_key(&mut d)?;
626        if self.alg.is_some() {
627            self.verify_kty()?;
628        } else {
629            self.verify_curve()?;
630        }
631        Ok(())
632    }
633
634    pub(crate) fn decode_key(&mut self, d: &mut Decoder<Cursor<Vec<u8>>>) -> CoseResult {
635        let mut label: i32;
636        let mut labels_found = Vec::new();
637        self.used = Vec::new();
638        for _ in 0..d.object()? {
639            label = d.i32()?;
640            if !labels_found.contains(&label) {
641                labels_found.push(label);
642            } else {
643                return Err(CoseError::DuplicateLabel(label));
644            }
645            match label {
646                KTY => {
647                    let type_info = d.kernel().typeinfo()?;
648                    if type_info.0 == Type::Text {
649                        self.kty = Some(common::get_kty_id(
650                            from_utf8(&d.kernel().raw_data(type_info.1, common::MAX_BYTES)?)
651                                .unwrap()
652                                .to_string(),
653                        )?);
654                    } else if common::CBOR_NUMBER_TYPES.contains(&type_info.0) {
655                        self.kty = Some(d.kernel().i32(&type_info)?);
656                    } else {
657                        return Err(CoseError::InvalidCoseStructure());
658                    }
659                    self.used.push(label);
660                }
661                ALG => {
662                    let type_info = d.kernel().typeinfo()?;
663                    if type_info.0 == Type::Text {
664                        self.alg = Some(common::get_alg_id(
665                            from_utf8(&d.kernel().raw_data(type_info.1, common::MAX_BYTES)?)
666                                .unwrap()
667                                .to_string(),
668                        )?);
669                    } else if common::CBOR_NUMBER_TYPES.contains(&type_info.0) {
670                        self.alg = Some(d.kernel().i32(&type_info)?);
671                    } else {
672                        return Err(CoseError::InvalidCoseStructure());
673                    }
674                    self.used.push(label);
675                }
676                KID => {
677                    self.kid = Some(d.bytes()?);
678                    self.used.push(label);
679                }
680                KEY_OPS => {
681                    let mut key_ops = Vec::new();
682                    for _i in 0..d.array()? {
683                        let type_info = d.kernel().typeinfo()?;
684                        if type_info.0 == Type::Text {
685                            key_ops.push(common::get_key_op_id(
686                                from_utf8(&d.kernel().raw_data(type_info.1, common::MAX_BYTES)?)
687                                    .unwrap()
688                                    .to_string(),
689                            )?);
690                        } else if common::CBOR_NUMBER_TYPES.contains(&type_info.0) {
691                            key_ops.push(d.kernel().i32(&type_info)?);
692                        } else {
693                            return Err(CoseError::InvalidCoseStructure());
694                        }
695                    }
696                    self.key_ops = key_ops;
697                    self.used.push(label);
698                }
699                BASE_IV => {
700                    self.base_iv = Some(d.bytes()?);
701                    self.used.push(label);
702                }
703                CRV_K => {
704                    let type_info = d.kernel().typeinfo()?;
705                    if type_info.0 == Type::Text {
706                        self.crv = Some(common::get_crv_id(
707                            from_utf8(&d.kernel().raw_data(type_info.1, common::MAX_BYTES)?)
708                                .unwrap()
709                                .to_string(),
710                        )?);
711                    } else if common::CBOR_NUMBER_TYPES.contains(&type_info.0) {
712                        self.crv = Some(d.kernel().i32(&type_info)?);
713                    } else if type_info.0 == Type::Bytes {
714                        self.k = Some(d.kernel().raw_data(type_info.1, common::MAX_BYTES)?);
715                    } else {
716                        return Err(CoseError::InvalidCoseStructure());
717                    }
718                    self.used.push(label);
719                }
720                X => {
721                    self.x = Some(d.bytes()?);
722                    self.used.push(label);
723                }
724                Y => {
725                    let type_info = d.kernel().typeinfo()?;
726                    if type_info.0 == Type::Bytes {
727                        self.y = Some(d.kernel().raw_data(type_info.1, common::MAX_BYTES)?);
728                    } else if type_info.0 == Type::Bool {
729                        self.y_parity = Some(d.kernel().bool(&type_info)?);
730                    } else {
731                        return Err(CoseError::InvalidCoseStructure());
732                    }
733                    self.used.push(label);
734                }
735                D => {
736                    self.d = Some(d.bytes()?);
737                    self.used.push(label);
738                }
739                Q => {
740                    self.q = Some(d.bytes()?);
741                    self.used.push(label);
742                }
743                DP => {
744                    self.dp = Some(d.bytes()?);
745                    self.used.push(label);
746                }
747                DQ => {
748                    self.dq = Some(d.bytes()?);
749                    self.used.push(label);
750                }
751                QINV => {
752                    self.qinv = Some(d.bytes()?);
753                    self.used.push(label);
754                }
755                OTHER => {
756                    let mut other = Vec::new();
757                    for _ in 0..d.array()? {
758                        if d.object()? != 3 {
759                            return Err(CoseError::Invalid(CoseField::Other));
760                        }
761                        let mut ri = Vec::new();
762                        let mut di = Vec::new();
763                        let mut ti = Vec::new();
764
765                        for _ in 0..3 {
766                            let other_label = d.i32()?;
767                            if other_label == RI {
768                                ri = d.bytes()?;
769                            } else if other_label == DI {
770                                di = d.bytes()?;
771                            } else if other_label == TI {
772                                ti = d.bytes()?;
773                            } else {
774                                return Err(CoseError::Invalid(CoseField::Other));
775                            }
776                        }
777                        other.push([ri, di, ti].to_vec());
778                    }
779                    self.other = Some(other);
780                    self.used.push(label);
781                }
782                _ => {
783                    return Err(CoseError::InvalidLabel(label));
784                }
785            }
786        }
787        if self.kty.ok_or(CoseError::Missing(CoseField::Kty))? == RSA {
788            if self.k.is_some() {
789                self.n = std::mem::take(&mut self.k);
790            }
791            if self.x.is_some() {
792                self.e = std::mem::take(&mut self.x);
793            }
794            if self.y.is_some() {
795                self.rsa_d = std::mem::take(&mut self.y);
796            }
797            if self.d.is_some() {
798                self.p = std::mem::take(&mut self.d);
799            }
800        }
801        self.verify_key_ops()?;
802        Ok(())
803    }
804
805    pub(crate) fn get_s_key(&self) -> CoseResultWithRet<Vec<u8>> {
806        let kty = self.kty.ok_or(CoseError::Missing(CoseField::Kty))?;
807        match kty {
808            EC2 | OKP => {
809                let d = self
810                    .d
811                    .as_ref()
812                    .ok_or(CoseError::Missing(CoseField::D))?
813                    .to_vec();
814                if d.len() <= 0 {
815                    return Err(CoseError::Missing(CoseField::D));
816                }
817                Ok(d)
818            }
819            RSA => Ok(Rsa::from_private_components(
820                BigNum::from_slice(self.n.as_ref().ok_or(CoseError::Missing(CoseField::N))?)?,
821                BigNum::from_slice(self.e.as_ref().ok_or(CoseError::Missing(CoseField::E))?)?,
822                BigNum::from_slice(
823                    self.rsa_d
824                        .as_ref()
825                        .ok_or(CoseError::Missing(CoseField::RsaD))?,
826                )?,
827                BigNum::from_slice(self.p.as_ref().ok_or(CoseError::Missing(CoseField::P))?)?,
828                BigNum::from_slice(self.q.as_ref().ok_or(CoseError::Missing(CoseField::Q))?)?,
829                BigNum::from_slice(self.dp.as_ref().ok_or(CoseError::Missing(CoseField::DP))?)?,
830                BigNum::from_slice(self.dq.as_ref().ok_or(CoseError::Missing(CoseField::DQ))?)?,
831                BigNum::from_slice(
832                    self.qinv
833                        .as_ref()
834                        .ok_or(CoseError::Missing(CoseField::QInv))?,
835                )?,
836            )?
837            .private_key_to_der()?),
838            SYMMETRIC => {
839                let k = self
840                    .k
841                    .as_ref()
842                    .ok_or(CoseError::Missing(CoseField::K))?
843                    .to_vec();
844                if k.len() <= 0 {
845                    return Err(CoseError::Missing(CoseField::K));
846                }
847                Ok(k)
848            }
849            _ => Err(CoseError::Invalid(CoseField::Kty)),
850        }
851    }
852    pub(crate) fn get_pub_key(&self) -> CoseResultWithRet<Vec<u8>> {
853        let kty = self.kty.ok_or(CoseError::Missing(CoseField::Kty))?;
854        match kty {
855            EC2 | OKP => {
856                let mut x = self
857                    .x
858                    .as_ref()
859                    .ok_or(CoseError::Missing(CoseField::X))?
860                    .to_vec();
861                if x.len() <= 0 {
862                    return Err(CoseError::Missing(CoseField::X));
863                }
864                let mut pub_key;
865                if kty == EC2 {
866                    if self.y != None && self.y.as_ref().unwrap().len() > 0 {
867                        let mut y = self.y.as_ref().unwrap().to_vec();
868                        pub_key = vec![4];
869                        pub_key.append(&mut x);
870                        pub_key.append(&mut y);
871                    } else {
872                        if self.y_parity.is_some() {
873                            if self.y_parity.unwrap() {
874                                pub_key = vec![3];
875                            } else {
876                                pub_key = vec![2];
877                            }
878                            pub_key.append(&mut x);
879                        } else {
880                            return Err(CoseError::Missing(CoseField::Y));
881                        }
882                    }
883                } else {
884                    pub_key = x;
885                }
886                Ok(pub_key)
887            }
888            RSA => Ok(Rsa::from_public_components(
889                BigNum::from_slice(self.n.as_ref().ok_or(CoseError::Missing(CoseField::N))?)?,
890                BigNum::from_slice(self.e.as_ref().ok_or(CoseError::Missing(CoseField::E))?)?,
891            )?
892            .public_key_to_der()?),
893            _ => Err(CoseError::Invalid(CoseField::Kty)),
894        }
895    }
896}
897
898/// cose-keySet structure.
899pub struct CoseKeySet {
900    /// List of the cose-keys.
901    pub cose_keys: Vec<CoseKey>,
902    /// COSE encoded key set.
903    pub bytes: Vec<u8>,
904}
905
906impl CoseKeySet {
907    /// Creates a new empty structure.
908    pub fn new() -> CoseKeySet {
909        CoseKeySet {
910            cose_keys: Vec::new(),
911            bytes: Vec::new(),
912        }
913    }
914
915    /// Adds a cose-key to the cose-keySet.
916    pub fn add_key(&mut self, key: &CoseKey) {
917        self.cose_keys.push(key.clone());
918    }
919
920    /// Encodes the cose-keySet.
921    pub fn encode(&mut self) -> CoseResult {
922        let mut e = Encoder::new(Vec::new());
923        let len = self.cose_keys.len();
924        if len > 0 {
925            e.array(len)?;
926            for i in 0..len {
927                self.cose_keys[i].encode_key(&mut e)?;
928            }
929            self.bytes = e.into_writer().to_vec();
930            Ok(())
931        } else {
932            Err(CoseError::MissingKey())
933        }
934    }
935
936    /// Decodes an encoded cose-keySet.
937    ///
938    /// The COSE encoded bytes of the cose-keySet must be set with the structure attribute bytes beforehand.
939    pub fn decode(&mut self) -> CoseResult {
940        let input = Cursor::new(self.bytes.clone());
941        let mut d = Decoder::new(Config::default(), input);
942        let len = d.array()?;
943        if len > 0 {
944            for _ in 0..len {
945                let mut cose_key = CoseKey::new();
946                match cose_key.decode_key(&mut d) {
947                    Ok(_v) => self.cose_keys.push(cose_key),
948                    Err(_e) => (),
949                }
950            }
951            Ok(())
952        } else {
953            Err(CoseError::MissingKey())
954        }
955    }
956
957    /// Function that returns a cose-key from the cose-keySet with a given Key ID.
958    pub fn get_key(&self, kid: &Vec<u8>) -> CoseResultWithRet<CoseKey> {
959        for i in 0..self.cose_keys.len() {
960            if self.cose_keys[i]
961                .kid
962                .as_ref()
963                .ok_or(CoseError::Missing(CoseField::Kid))?
964                == kid
965            {
966                return Ok(self.cose_keys[i].clone());
967            }
968        }
969        Err(CoseError::MissingKey())
970    }
971}
cose/keys.rs

cose/
keys.rs
