Rev

Rev 3274 | Details | Compare with Previous | Last modification | View Log | SVN | Bug Tracker

Rev Author Line No. Line
3078 garciay 1
module ItsGenCert_Functions {
2
 
3086 garciay 3
  // LibIts
4
  import from IEEE1609dot2BaseTypes language "ASN.1:1997" all;
5
  import from IEEE1609dot2 language "ASN.1:1997" all;
6
  import from EtsiTs103097Module language "ASN.1:1997" all;
3078 garciay 7
 
3086 garciay 8
  // LibItsSecurity
9
  import from LibItsSecurity_EncdecDeclarations all;
10
  import from LibItsSecurity_TypesAndValues all;
11
  import from LibItsSecurity_Templates all;
12
  import from LibItsSecurity_Functions all;
13
  import from LibItsSecurity_Pixits all;
3078 garciay 14
 
3086 garciay 15
  // AtsGenCert
16
  import from ItsGenCert_TypeAndValues all;
17
  import from ItsGenCert_Templates all;
18
  import from ItsGenCert_Pics all;
3078 garciay 19
 
3086 garciay 20
  function f_generate_signing_keys(
21
                                   in certificate_params p_certificate_params,
22
                                   inout certificate_details p_certificate_details
23
                                   ) return integer {
24
    if (p_certificate_params.curve == e_nist_p256) {
3179 garciay 25
      f_generate_key_pair_nistp256(p_certificate_details.private_key, p_certificate_details.public_key_x, p_certificate_details.public_key_y, p_certificate_details.public_key_compressed, p_certificate_details.public_key_compressed_mode);
3086 garciay 26
    } else if (p_certificate_params.curve == e_brainpool_p256) {
3179 garciay 27
      f_generate_key_pair_brainpoolp256(p_certificate_details.private_key, p_certificate_details.public_key_x, p_certificate_details.public_key_y, p_certificate_details.public_key_compressed, p_certificate_details.public_key_compressed_mode);
3099 garciay 28
    } else if (p_certificate_params.curve == e_brainpool_p384) {
3179 garciay 29
      f_generate_key_pair_brainpoolp384(p_certificate_details.private_key, p_certificate_details.public_key_x, p_certificate_details.public_key_y, p_certificate_details.public_key_compressed, p_certificate_details.public_key_compressed_mode);
3086 garciay 30
    } else {
31
      log("f_generate_signing_keys: Unsupported curve");
32
      return -1;
33
    }
3092 garciay 34
 
3099 garciay 35
    if (p_certificate_params.encryption_key == true) {
36
      if (p_certificate_params.encryption_curve == e_nist_p256) {
3187 garciay 37
        f_generate_key_pair_nistp256(p_certificate_details.private_enc_key, p_certificate_details.public_enc_key_x, p_certificate_details.public_enc_key_y, p_certificate_details.public_enc_key_compressed, p_certificate_details.public_enc_key_compressed_mode);
3099 garciay 38
      } else if (p_certificate_params.encryption_curve == e_brainpool_p256) {
3187 garciay 39
        f_generate_key_pair_brainpoolp256(p_certificate_details.private_enc_key, p_certificate_details.public_enc_key_x, p_certificate_details.public_enc_key_y, p_certificate_details.public_enc_key_compressed, p_certificate_details.public_enc_key_compressed_mode);
3099 garciay 40
      } else {
41
        log("f_generate_signing_keys: Unsupported encryption curve");
42
        return -1;
43
      }
44
    }
45
 
3086 garciay 46
    return 0;
47
  } // End of function f_generate_signing_keys
3080 garciay 48
 
3086 garciay 49
  function f_fill_certificate(
50
                              in certificate_params p_certificate_params,
51
                              inout certificate_details p_certificate_details
52
                              ) return integer {
3179 garciay 53
  var VerificationKeyIndicator v_publicVerificationKey;
54
  if (p_certificate_params.curve == e_nist_p256) {
55
    if (p_certificate_details.public_key_compressed_mode == 0) {
56
      v_publicVerificationKey := valueof(
57
                                         m_verificationKeyIndicator_verificationKey(
58
                                                                                    m_publicVerificationKey_ecdsaNistP256(
59
                                                                                                                          m_eccP256CurvePoint_compressed_y_0(
60
                                                                                                                                                             p_certificate_details.public_key_compressed
61
                                        ))));
62
    } else {
63
      v_publicVerificationKey := valueof(
64
                                         m_verificationKeyIndicator_verificationKey(
65
                                                                                    m_publicVerificationKey_ecdsaNistP256(
66
                                                                                                                          m_eccP256CurvePoint_compressed_y_1(
67
                                                                                                                                                             p_certificate_details.public_key_compressed
68
                                        ))));
69
    }
70
  } else if (p_certificate_params.curve == e_brainpool_p256) {
71
    if (p_certificate_details.public_key_compressed_mode == 0) {
72
      v_publicVerificationKey := valueof(
73
                                         m_verificationKeyIndicator_verificationKey(
74
                                                                                    m_publicVerificationKey_ecdsaBrainpoolP256r1(
75
                                                                                                                                 m_eccP256CurvePoint_compressed_y_0(
76
                                                                                                                                                                    p_certificate_details.public_key_compressed
77
                                        ))));
78
    } else {
79
      v_publicVerificationKey := valueof(
80
                                         m_verificationKeyIndicator_verificationKey(
81
                                                                                    m_publicVerificationKey_ecdsaBrainpoolP256r1(
82
                                                                                                                                 m_eccP256CurvePoint_compressed_y_1(
83
                                                                                                                                                                    p_certificate_details.public_key_compressed
84
                                        ))));
85
    }
86
  } else {
87
    if (p_certificate_details.public_key_compressed_mode == 0) {
88
      v_publicVerificationKey := valueof(
89
                                         m_verificationKeyIndicator_verificationKey(
90
                                                                                    m_publicVerificationKey_ecdsaBrainpoolP384r1(
91
                                                                                                                                 m_eccP384CurvePoint_compressed_y_0(
92
                                                                                                                                                                    p_certificate_details.public_key_compressed
93
                                        ))));
94
    } else {
95
      v_publicVerificationKey := valueof(
96
                                         m_verificationKeyIndicator_verificationKey(
97
                                                                                    m_publicVerificationKey_ecdsaBrainpoolP384r1(
98
                                                                                                                                 m_eccP384CurvePoint_compressed_y_1(
99
                                                                                                                                                                    p_certificate_details.public_key_compressed
100
                                        ))));
101
    }
102
  }
3086 garciay 103
  p_certificate_details.certificate := valueof(
104
                                               m_etsiTs103097Certificate(
105
                                                                         m_issuerIdentifier_self(p_certificate_params.hash_algorithm),
106
                                                                         m_toBeSignedCertificate(
107
                                                                                                 { name := p_certificate_params.certificate_id },
3179 garciay 108
                                                                                                 v_publicVerificationKey,
3086 garciay 109
                                                                                                 p_certificate_params.validity_period,
110
                                                                                                 p_certificate_params.region,
3089 garciay 111
                                                                                                 p_certificate_params.app_permissions,
112
                                                                                                 p_certificate_params.issuing_permissions
3099 garciay 113
                                                                               )
114
                                                                )
115
                                               );
116
    if (p_certificate_params.encryption_key == true) {
117
      if (p_certificate_params.encryption_curve == e_nist_p256) {
3187 garciay 118
        if (p_certificate_details.public_enc_key_compressed_mode == 0) {
119
          p_certificate_details.certificate.toBeSigned.encryptionKey := valueof(m_encryptionKey(
120
                                                                                                aes128Ccm,
121
                                                                                                m_publicEncryptionKey_ecdsaNistP256(
122
                                                                                                                                    m_eccP256CurvePoint_compressed_y_0(
123
                                                                                                                                                                       p_certificate_details.public_enc_key_compressed
124
                                                                                                                                                                       )))
125
                                                                               );
126
        } else {
127
          p_certificate_details.certificate.toBeSigned.encryptionKey := valueof(m_encryptionKey(
128
                                                                                                aes128Ccm,
129
                                                                                                m_publicEncryptionKey_ecdsaNistP256(
130
                                                                                                                                    m_eccP256CurvePoint_compressed_y_1(
131
                                                                                                                                                                       p_certificate_details.public_enc_key_compressed
132
                                                                                                                                                                       )))
3099 garciay 133
                                                                             );
3187 garciay 134
        }
3099 garciay 135
      } else if (p_certificate_params.encryption_curve == e_brainpool_p256) {
3187 garciay 136
        if (p_certificate_details.public_enc_key_compressed_mode == 0) {
137
          p_certificate_details.certificate.toBeSigned.encryptionKey := valueof(m_encryptionKey(
138
                                                                                                aes128Ccm,
139
                                                                                                m_publicEncryptionKey_eciesBrainpoolP256r1(
140
                                                                                                                                           m_eccP256CurvePoint_compressed_y_0(
141
                                                                                                                                                                              p_certificate_details.public_enc_key_compressed
142
                                                                                                                                                                              )))
143
                                                                               );
144
        } else {
145
          p_certificate_details.certificate.toBeSigned.encryptionKey := valueof(m_encryptionKey(
146
                                                                                                aes128Ccm,
147
                                                                                                m_publicEncryptionKey_eciesBrainpoolP256r1(
148
                                                                                                                                           m_eccP256CurvePoint_compressed_y_1(
149
                                                                                                                                                                              p_certificate_details.public_enc_key_compressed
150
                                                                                                                                                                              )))
151
                                                                               );
152
        }
3099 garciay 153
      }
154
    }
3089 garciay 155
 
3086 garciay 156
    return 0;
157
  } // End of function f_fill_certificate
3078 garciay 158
 
3086 garciay 159
  function f_generate_certificate(
160
                                  in certificate_params p_certificate_params,
3093 garciay 161
                                  in certificate_details p_issuer_certificate_details,
3086 garciay 162
                                  inout certificate_details p_certificate_details
163
                                  ) return integer {
164
    var bitstring v_enc_msg;
3187 garciay 165
    var octetstring v_issuer;
3086 garciay 166
    var octetstring v_signature;
3190 garciay 167
 
3086 garciay 168
    // Encode it ==> Get octetstring
3093 garciay 169
    v_enc_msg := encvalue(p_certificate_details.certificate.toBeSigned);
3179 garciay 170
 
3086 garciay 171
    // Sign the certificate using ECDSA/SHA-256 (NIST p-256)
172
    if (p_certificate_params.curve == e_nist_p256) {
3190 garciay 173
      if (p_issuer_certificate_details.certificate_id != p_certificate_details.certificate_id) { // This is not a CA certificate
3274 garciay 174
        v_issuer := p_issuer_certificate_details.hash;
3187 garciay 175
      } else {
3271 garciay 176
        v_issuer := int2oct(0, 32); // Hash of empty string
3187 garciay 177
      }
178
      v_signature := f_signWithEcdsaNistp256WithSha256(bit2oct(v_enc_msg), v_issuer, p_issuer_certificate_details.private_key);
3107 garciay 179
      if (lengthof(v_signature) != 64) {
180
        setverdict(fail, "Wrong signature size, shall be 64 instead of ", lengthof(v_signature));
181
        stop;
182
      }
3099 garciay 183
      p_certificate_details.certificate.signature_ := valueof(
184
                                                              m_signature_ecdsaNistP256(
185
                                                                                        m_ecdsaP256Signature(
186
                                                                                                             m_eccP256CurvePoint_x_only(
187
                                                                                                                                        substr(v_signature, 0, 32)
188
                                                                                                                                        ),
189
                                                                                                             substr(v_signature, 32, 32)
190
                                                                                                             )
191
                                                                                        ));
3086 garciay 192
    } else if (p_certificate_params.curve == e_brainpool_p256) {
3187 garciay 193
      if (p_issuer_certificate_details.issuer != p_issuer_certificate_details.hashid8) { // This is not a CA certificate
3274 garciay 194
        v_issuer := p_issuer_certificate_details.hash;
3187 garciay 195
      } else {
3271 garciay 196
        v_issuer := int2oct(0, 32); // Hash of empty string
3187 garciay 197
      }
3184 garciay 198
      v_signature := f_signWithEcdsaBrainpoolp256WithSha256(bit2oct(v_enc_msg), v_issuer, p_issuer_certificate_details.private_key);
3107 garciay 199
      if (lengthof(v_signature) != 64) {
200
        setverdict(fail, "Wrong signature size, shall be 64 instead of ", lengthof(v_signature));
201
        stop;
202
      }
3099 garciay 203
      p_certificate_details.certificate.signature_ := valueof(
204
                                                              m_signature_ecdsaBrainpoolP256r1(
205
                                                                                               m_ecdsaP256Signature(
206
                                                                                                                    m_eccP256CurvePoint_x_only(
207
                                                                                                                                               substr(v_signature, 0, 32)
208
                                                                                                                                               ),
209
                                                                                                                    substr(v_signature, 32, 32)
210
                                                                                                                    )
211
                                                                                               ));
212
    } else if (p_certificate_params.curve == e_brainpool_p384) {
3187 garciay 213
      if (p_issuer_certificate_details.issuer != p_issuer_certificate_details.hashid8) { // This is not a CA certificate
3271 garciay 214
        v_issuer := p_issuer_certificate_details.hash;
3187 garciay 215
      } else {
3271 garciay 216
        v_issuer := int2oct(0, 48);
3187 garciay 217
      }
3184 garciay 218
      v_signature := f_signWithEcdsaBrainpoolp384WithSha384(bit2oct(v_enc_msg), v_issuer, p_issuer_certificate_details.private_key);
3107 garciay 219
      if (lengthof(v_signature) != 96) {
220
        setverdict(fail, "Wrong signature size, shall be 96 instead of ", lengthof(v_signature));
221
        stop;
222
      }
3099 garciay 223
      p_certificate_details.certificate.signature_ := valueof(m_signature_ecdsaBrainpoolP384r1(
224
                                                                                               m_ecdsaP384Signature(
225
                                                                                                                    m_eccP384CurvePoint_x_only(
226
                                                                                                                                               substr(v_signature, 0, 48)
227
                                                                                                                                               ),
228
                                                                                                                    substr(v_signature, 48, 48)
229
                                                                                                                    )
230
                                                                                               ));
3086 garciay 231
    } else {
232
      log("f_generate_certificate: Unsupported curve");
233
      return -1;
234
    }
3080 garciay 235
 
3086 garciay 236
    return 0;
237
  } // End of function f_generate_certificate
3080 garciay 238
 
3086 garciay 239
  function f_finalyse_certificate(
240
                                  in certificate_params p_certificate_params,
241
                                  in certificate_details_list p_certificate_details_list,
242
                                  inout certificate_details p_certificate_details
243
                                  ) return integer {
244
    // Set the issuer
245
    if (p_certificate_params.certificate_id != p_certificate_params.signed_by) {
246
      // Find the issuer in the list
247
      var boolean v_found := false;
248
      for (var integer v_counter := 0; v_counter < lengthof(p_certificate_details_list); v_counter := v_counter + 1) {
3089 garciay 249
        log("f_finalyse_certificate: compare ", p_certificate_details_list[v_counter].certificate_id, " with ", p_certificate_params.signed_by);
3086 garciay 250
        if (p_certificate_details_list[v_counter].certificate_id == p_certificate_params.signed_by) {
3089 garciay 251
          log("f_finalyse_certificate: Got it");
3086 garciay 252
          v_found := true;
253
          p_certificate_details.issuer := p_certificate_details_list[v_counter].hashid8;
3274 garciay 254
          p_certificate_details.hash := p_certificate_details_list[v_counter].hash;
3086 garciay 255
          if (p_certificate_params.hash_algorithm == sha256) {
256
            p_certificate_details.certificate.issuer.sha256AndDigest := p_certificate_details_list[v_counter].hashid8;
257
          } else if (p_certificate_params.hash_algorithm == sha384) {
258
            p_certificate_details.certificate.issuer.sha384AndDigest := p_certificate_details_list[v_counter].hashid8;
259
          } else {
260
            log("f_finalyse_certificate: Unsupported hash algorithm");
261
            return -1;
262
          }
263
          break;
3080 garciay 264
        }
3086 garciay 265
      } // End of 'for' statement
266
      if (v_found == false) {
267
        log("f_finalyse_certificate: issuer not found");
268
        return -1;
269
      }
270
    }
271
    // Encode the certificate
272
    p_certificate_details.enc_cert := bit2oct(encvalue(p_certificate_details.certificate));
3260 garciay 273
    // Calculate the whole HashedId8 as defined in IEEE Std 1609.2-20XX Clause 6.4.3 CertificateBase
3086 garciay 274
    if (p_certificate_params.hash_algorithm == sha256) {
3274 garciay 275
      p_certificate_details.hash := f_hashWithSha256(p_certificate_details.enc_cert); // Hash of the whole certificate
3271 garciay 276
      p_certificate_details.hashid8 := f_HashedId8FromSha256(p_certificate_details.hash);
3086 garciay 277
    } else {
3274 garciay 278
      p_certificate_details.hash := f_hashWithSha384(p_certificate_details.enc_cert); // Hash of the whole certificate
3271 garciay 279
      p_certificate_details.hashid8 := f_HashedId8FromSha384(p_certificate_details.hash);
3086 garciay 280
    }
281
    if (p_certificate_params.certificate_id == p_certificate_params.signed_by) { // Root certificate
282
      log("f_finalyse_certificate: Root certificate");
283
      p_certificate_details.issuer := p_certificate_details.hashid8
3092 garciay 284
    }
285
 
3086 garciay 286
    return 0;
287
  } // End of function f_finalyse_certificate
3092 garciay 288
 
3086 garciay 289
  function f_store_certificates(
290
                                in certificate_details_list p_certificate_details_list
291
                                ) return integer {
3088 garciay 292
    fx_loadCertificates(PX_CERTIFICATE_POOL_PATH, PX_IUT_SEC_CONFIG_NAME);
3086 garciay 293
    for (var integer v_counter := 0; v_counter < lengthof(p_certificate_details_list); v_counter := v_counter + 1) {
3089 garciay 294
      log("f_store_certificates: ", p_certificate_details_list[v_counter]);
3099 garciay 295
      if (ispresent(p_certificate_details_list[v_counter].private_enc_key)) {
296
        fx_store_certificate(
297
                             p_certificate_details_list[v_counter].certificate_id,
298
                             p_certificate_details_list[v_counter].enc_cert,
299
                             p_certificate_details_list[v_counter].private_key,
300
                             p_certificate_details_list[v_counter].public_key_x,
301
                             p_certificate_details_list[v_counter].public_key_y,
3179 garciay 302
                             p_certificate_details_list[v_counter].public_key_compressed,
303
                             p_certificate_details_list[v_counter].public_key_compressed_mode,
3348 garciay 304
                             p_certificate_details_list[v_counter].hash,
3099 garciay 305
                             p_certificate_details_list[v_counter].hashid8,
306
                             p_certificate_details_list[v_counter].issuer,
307
                             p_certificate_details_list[v_counter].private_enc_key,
308
                             p_certificate_details_list[v_counter].public_enc_key_x,
3257 garciay 309
                             p_certificate_details_list[v_counter].public_enc_key_y,
310
                             p_certificate_details_list[v_counter].public_enc_key_compressed,
311
                             p_certificate_details_list[v_counter].public_enc_key_compressed_mode);
3099 garciay 312
      } else {
313
        fx_store_certificate(
314
                             p_certificate_details_list[v_counter].certificate_id,
315
                             p_certificate_details_list[v_counter].enc_cert,
316
                             p_certificate_details_list[v_counter].private_key,
317
                             p_certificate_details_list[v_counter].public_key_x,
318
                             p_certificate_details_list[v_counter].public_key_y,
3179 garciay 319
                             p_certificate_details_list[v_counter].public_key_compressed,
320
                             p_certificate_details_list[v_counter].public_key_compressed_mode,
3348 garciay 321
                             p_certificate_details_list[v_counter].hash,
3099 garciay 322
                             p_certificate_details_list[v_counter].hashid8,
323
                             p_certificate_details_list[v_counter].issuer,
3257 garciay 324
                             omit,
325
                             omit,
326
                             omit,
327
                             omit,
328
                             omit);
3099 garciay 329
      }
3086 garciay 330
    } // End of 'for' statement
331
 
332
    return 0;
333
  } // End of function f_store_certificates
334
 
3078 garciay 335
} // End of module ItsGenCert_Functions