ua_securitypolicy_basic128rsa15.c 42 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022
  1. /* This Source Code Form is subject to the terms of the Mozilla Public
  2. * License, v. 2.0. If a copy of the MPL was not distributed with this
  3. * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  4. *
  5. * Copyright 2018 (c) Mark Giraud, Fraunhofer IOSB
  6. */
  7. #include <mbedtls/aes.h>
  8. #include <mbedtls/md.h>
  9. #include <mbedtls/x509_crt.h>
  10. #include <mbedtls/ctr_drbg.h>
  11. #include <mbedtls/entropy.h>
  12. #include <mbedtls/entropy_poll.h>
  13. #include <mbedtls/error.h>
  14. #include <mbedtls/version.h>
  15. #include <mbedtls/sha1.h>
  16. #include "ua_types.h"
  17. #include "ua_plugin_pki.h"
  18. #include "ua_securitypolicies.h"
  19. #include "ua_types_generated_handling.h"
  20. /* Notes:
  21. * mbedTLS' AES allows in-place encryption and decryption. Sow we don't have to
  22. * allocate temp buffers.
  23. * https://tls.mbed.org/discussions/generic/in-place-decryption-with-aes256-same-input-output-buffer
  24. */
  25. #define UA_SECURITYPOLICY_BASIC128RSA15_RSAPADDING_LEN 11
  26. #define UA_SHA1_LENGTH 20
  27. #define UA_SECURITYPOLICY_BASIC128RSA15_SYM_KEY_LENGTH 16
  28. #define UA_BASIC128RSA15_SYM_SIGNING_KEY_LENGTH 16
  29. #define UA_SECURITYPOLICY_BASIC128RSA15_SYM_ENCRYPTION_BLOCK_SIZE 16
  30. #define UA_SECURITYPOLICY_BASIC128RSA15_SYM_PLAIN_TEXT_BLOCK_SIZE 16
  31. #define UA_SECURITYPOLICY_BASIC128RSA15_MINASYMKEYLENGTH 128
  32. #define UA_SECURITYPOLICY_BASIC128RSA15_MAXASYMKEYLENGTH 256
  33. #define UA_LOG_MBEDERR \
  34. char errBuff[300]; \
  35. mbedtls_strerror(mbedErr, errBuff, 300); \
  36. UA_LOG_WARNING(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, \
  37. "mbedTLS returned an error: %s", errBuff); \
  38. #define UA_MBEDTLS_ERRORHANDLING(errorcode) \
  39. if(mbedErr) { \
  40. UA_LOG_MBEDERR \
  41. retval = errorcode; \
  42. }
  43. #define UA_MBEDTLS_ERRORHANDLING_RETURN(errorcode) \
  44. if(mbedErr) { \
  45. UA_LOG_MBEDERR \
  46. return errorcode; \
  47. }
  48. typedef struct {
  49. const UA_SecurityPolicy *securityPolicy;
  50. UA_ByteString localCertThumbprint;
  51. mbedtls_ctr_drbg_context drbgContext;
  52. mbedtls_entropy_context entropyContext;
  53. mbedtls_md_context_t sha1MdContext;
  54. mbedtls_pk_context localPrivateKey;
  55. } Basic128Rsa15_PolicyContext;
  56. typedef struct {
  57. Basic128Rsa15_PolicyContext *policyContext;
  58. UA_ByteString localSymSigningKey;
  59. UA_ByteString localSymEncryptingKey;
  60. UA_ByteString localSymIv;
  61. UA_ByteString remoteSymSigningKey;
  62. UA_ByteString remoteSymEncryptingKey;
  63. UA_ByteString remoteSymIv;
  64. mbedtls_x509_crt remoteCertificate;
  65. } Basic128Rsa15_ChannelContext;
  66. /********************/
  67. /* AsymmetricModule */
  68. /********************/
  69. static UA_StatusCode
  70. asym_verify_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  71. Basic128Rsa15_ChannelContext *cc,
  72. const UA_ByteString *message,
  73. const UA_ByteString *signature) {
  74. if(securityPolicy == NULL || message == NULL || signature == NULL || cc == NULL)
  75. return UA_STATUSCODE_BADINTERNALERROR;
  76. /* Compute the sha1 hash */
  77. unsigned char hash[UA_SHA1_LENGTH];
  78. #if MBEDTLS_VERSION_NUMBER >= 0x02070000
  79. mbedtls_sha1_ret(message->data, message->length, hash);
  80. #else
  81. mbedtls_sha1(message->data, message->length, hash);
  82. #endif
  83. /* Set the RSA settings */
  84. mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk);
  85. if (!rsaContext)
  86. return UA_STATUSCODE_BADINTERNALERROR;
  87. mbedtls_rsa_set_padding(rsaContext, MBEDTLS_RSA_PKCS_V15, 0);
  88. /* Verify */
  89. int mbedErr = mbedtls_pk_verify(&cc->remoteCertificate.pk,
  90. MBEDTLS_MD_SHA1, hash, UA_SHA1_LENGTH,
  91. signature->data, signature->length);
  92. UA_MBEDTLS_ERRORHANDLING_RETURN(UA_STATUSCODE_BADSECURITYCHECKSFAILED);
  93. return UA_STATUSCODE_GOOD;
  94. }
  95. static UA_StatusCode
  96. asym_sign_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  97. Basic128Rsa15_ChannelContext *cc,
  98. const UA_ByteString *message,
  99. UA_ByteString *signature) {
  100. if(securityPolicy == NULL || message == NULL || signature == NULL || cc == NULL)
  101. return UA_STATUSCODE_BADINTERNALERROR;
  102. unsigned char hash[UA_SHA1_LENGTH];
  103. #if MBEDTLS_VERSION_NUMBER >= 0x02070000
  104. mbedtls_sha1_ret(message->data, message->length, hash);
  105. #else
  106. mbedtls_sha1(message->data, message->length, hash);
  107. #endif
  108. Basic128Rsa15_PolicyContext *pc = cc->policyContext;
  109. mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(pc->localPrivateKey);
  110. mbedtls_rsa_set_padding(rsaContext, MBEDTLS_RSA_PKCS_V15, 0);
  111. size_t sigLen = 0;
  112. int mbedErr = mbedtls_pk_sign(&pc->localPrivateKey,
  113. MBEDTLS_MD_SHA1, hash,
  114. UA_SHA1_LENGTH, signature->data,
  115. &sigLen, mbedtls_ctr_drbg_random,
  116. &pc->drbgContext);
  117. UA_MBEDTLS_ERRORHANDLING_RETURN(UA_STATUSCODE_BADINTERNALERROR);
  118. return UA_STATUSCODE_GOOD;
  119. }
  120. static size_t
  121. asym_getLocalSignatureSize_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  122. const Basic128Rsa15_ChannelContext *cc) {
  123. if(securityPolicy == NULL || cc == NULL)
  124. return 0;
  125. return mbedtls_pk_rsa(cc->policyContext->localPrivateKey)->len;
  126. }
  127. static size_t
  128. asym_getRemoteSignatureSize_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  129. const Basic128Rsa15_ChannelContext *cc) {
  130. if(securityPolicy == NULL || cc == NULL)
  131. return 0;
  132. return mbedtls_pk_rsa(cc->remoteCertificate.pk)->len;
  133. }
  134. static UA_StatusCode
  135. asym_encrypt_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  136. Basic128Rsa15_ChannelContext *cc,
  137. UA_ByteString *data) {
  138. if(securityPolicy == NULL || cc == NULL || data == NULL)
  139. return UA_STATUSCODE_BADINTERNALERROR;
  140. const size_t plainTextBlockSize = securityPolicy->asymmetricModule.cryptoModule.encryptionAlgorithm.
  141. getRemotePlainTextBlockSize(securityPolicy, cc);
  142. if(data->length % plainTextBlockSize != 0)
  143. return UA_STATUSCODE_BADINTERNALERROR;
  144. mbedtls_rsa_context *remoteRsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk);
  145. mbedtls_rsa_set_padding(remoteRsaContext, MBEDTLS_RSA_PKCS_V15, 0);
  146. UA_ByteString encrypted;
  147. const size_t bufferOverhead =
  148. UA_SecurityPolicy_getRemoteAsymEncryptionBufferLengthOverhead(securityPolicy, cc, data->length);
  149. UA_StatusCode retval = UA_ByteString_allocBuffer(&encrypted, data->length + bufferOverhead);
  150. if(retval != UA_STATUSCODE_GOOD)
  151. return retval;
  152. size_t lenDataToEncrypt = data->length;
  153. size_t inOffset = 0;
  154. size_t offset = 0;
  155. size_t outLength = 0;
  156. Basic128Rsa15_PolicyContext *pc = cc->policyContext;
  157. while(lenDataToEncrypt >= plainTextBlockSize) {
  158. int mbedErr = mbedtls_pk_encrypt(&cc->remoteCertificate.pk,
  159. data->data + inOffset, plainTextBlockSize,
  160. encrypted.data + offset, &outLength,
  161. encrypted.length - offset,
  162. mbedtls_ctr_drbg_random,
  163. &pc->drbgContext);
  164. UA_MBEDTLS_ERRORHANDLING(UA_STATUSCODE_BADINTERNALERROR);
  165. if(retval != UA_STATUSCODE_GOOD) {
  166. UA_ByteString_deleteMembers(&encrypted);
  167. return retval;
  168. }
  169. inOffset += plainTextBlockSize;
  170. offset += outLength;
  171. lenDataToEncrypt -= plainTextBlockSize;
  172. }
  173. memcpy(data->data, encrypted.data, offset);
  174. UA_ByteString_deleteMembers(&encrypted);
  175. return UA_STATUSCODE_GOOD;
  176. }
  177. static UA_StatusCode
  178. asym_decrypt_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  179. Basic128Rsa15_ChannelContext *cc,
  180. UA_ByteString *data) {
  181. if(securityPolicy == NULL || cc == NULL || data == NULL)
  182. return UA_STATUSCODE_BADINTERNALERROR;
  183. mbedtls_rsa_context *rsaContext =
  184. mbedtls_pk_rsa(cc->policyContext->localPrivateKey);
  185. mbedtls_rsa_set_padding(rsaContext, MBEDTLS_RSA_PKCS_V15, 0);
  186. if(data->length % rsaContext->len != 0)
  187. return UA_STATUSCODE_BADINTERNALERROR;
  188. UA_ByteString decrypted;
  189. UA_StatusCode retval = UA_ByteString_allocBuffer(&decrypted, data->length);
  190. if(retval != UA_STATUSCODE_GOOD)
  191. return retval;
  192. size_t lenDataToDecrypt = data->length;
  193. size_t inOffset = 0;
  194. size_t offset = 0;
  195. size_t outLength = 0;
  196. while(lenDataToDecrypt >= rsaContext->len) {
  197. int mbedErr = mbedtls_pk_decrypt(&cc->policyContext->localPrivateKey,
  198. data->data + inOffset, rsaContext->len,
  199. decrypted.data + offset, &outLength,
  200. decrypted.length - offset, NULL, NULL);
  201. if(mbedErr)
  202. UA_ByteString_deleteMembers(&decrypted); // TODO: Maybe change error macro to jump to cleanup?
  203. UA_MBEDTLS_ERRORHANDLING_RETURN(UA_STATUSCODE_BADSECURITYCHECKSFAILED);
  204. inOffset += rsaContext->len;
  205. offset += outLength;
  206. lenDataToDecrypt -= rsaContext->len;
  207. }
  208. if(lenDataToDecrypt == 0) {
  209. memcpy(data->data, decrypted.data, offset);
  210. data->length = offset;
  211. } else {
  212. retval = UA_STATUSCODE_BADINTERNALERROR;
  213. }
  214. UA_ByteString_deleteMembers(&decrypted);
  215. return retval;
  216. }
  217. static size_t
  218. asym_getRemoteEncryptionKeyLength_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  219. const Basic128Rsa15_ChannelContext *cc) {
  220. return mbedtls_pk_get_len(&cc->remoteCertificate.pk) * 8;
  221. }
  222. static size_t
  223. asym_getRemoteBlockSize_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  224. const Basic128Rsa15_ChannelContext *cc) {
  225. mbedtls_rsa_context *const rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk);
  226. return rsaContext->len;
  227. }
  228. static size_t
  229. asym_getRemotePlainTextBlockSize_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  230. const Basic128Rsa15_ChannelContext *cc) {
  231. mbedtls_rsa_context *const rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk);
  232. return rsaContext->len - UA_SECURITYPOLICY_BASIC128RSA15_RSAPADDING_LEN;
  233. }
  234. static UA_StatusCode
  235. asym_makeThumbprint_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  236. const UA_ByteString *certificate,
  237. UA_ByteString *thumbprint) {
  238. if(securityPolicy == NULL || certificate == NULL || thumbprint == NULL)
  239. return UA_STATUSCODE_BADINTERNALERROR;
  240. if(UA_ByteString_equal(certificate, &UA_BYTESTRING_NULL))
  241. return UA_STATUSCODE_BADINTERNALERROR;
  242. if(thumbprint->length != UA_SHA1_LENGTH)
  243. return UA_STATUSCODE_BADINTERNALERROR;
  244. #if MBEDTLS_VERSION_NUMBER >= 0x02070000
  245. mbedtls_sha1_ret(certificate->data, certificate->length, thumbprint->data);
  246. #else
  247. mbedtls_sha1(certificate->data, certificate->length, thumbprint->data);
  248. #endif
  249. return UA_STATUSCODE_GOOD;
  250. }
  251. static UA_StatusCode
  252. asymmetricModule_compareCertificateThumbprint_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  253. const UA_ByteString *certificateThumbprint) {
  254. if(securityPolicy == NULL || certificateThumbprint == NULL)
  255. return UA_STATUSCODE_BADINTERNALERROR;
  256. Basic128Rsa15_PolicyContext *pc = (Basic128Rsa15_PolicyContext *)securityPolicy->policyContext;
  257. if(!UA_ByteString_equal(certificateThumbprint, &pc->localCertThumbprint))
  258. return UA_STATUSCODE_BADCERTIFICATEINVALID;
  259. return UA_STATUSCODE_GOOD;
  260. }
  261. /*******************/
  262. /* SymmetricModule */
  263. /*******************/
  264. static void
  265. md_hmac(mbedtls_md_context_t *context, const UA_ByteString *key,
  266. const UA_ByteString *in, unsigned char out[20]) {
  267. mbedtls_md_hmac_starts(context, key->data, key->length);
  268. mbedtls_md_hmac_update(context, in->data, in->length);
  269. mbedtls_md_hmac_finish(context, out);
  270. }
  271. static UA_StatusCode
  272. sym_verify_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  273. Basic128Rsa15_ChannelContext *cc,
  274. const UA_ByteString *message,
  275. const UA_ByteString *signature) {
  276. if(securityPolicy == NULL || cc == NULL || message == NULL || signature == NULL)
  277. return UA_STATUSCODE_BADINTERNALERROR;
  278. /* Compute MAC */
  279. if(signature->length != UA_SHA1_LENGTH) {
  280. UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY,
  281. "Signature size does not have the desired size defined by the security policy");
  282. return UA_STATUSCODE_BADSECURITYCHECKSFAILED;
  283. }
  284. Basic128Rsa15_PolicyContext *pc =
  285. (Basic128Rsa15_PolicyContext *)securityPolicy->policyContext;
  286. unsigned char mac[UA_SHA1_LENGTH];
  287. md_hmac(&pc->sha1MdContext, &cc->remoteSymSigningKey, message, mac);
  288. /* Compare with Signature */
  289. if(memcmp(signature->data, mac, UA_SHA1_LENGTH) != 0)
  290. return UA_STATUSCODE_BADSECURITYCHECKSFAILED;
  291. return UA_STATUSCODE_GOOD;
  292. }
  293. static UA_StatusCode
  294. sym_sign_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  295. const Basic128Rsa15_ChannelContext *cc,
  296. const UA_ByteString *message,
  297. UA_ByteString *signature) {
  298. if(signature->length != UA_SHA1_LENGTH)
  299. return UA_STATUSCODE_BADINTERNALERROR;
  300. md_hmac(&cc->policyContext->sha1MdContext, &cc->localSymSigningKey,
  301. message, signature->data);
  302. return UA_STATUSCODE_GOOD;
  303. }
  304. static size_t
  305. sym_getSignatureSize_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  306. const void *channelContext) {
  307. return UA_SHA1_LENGTH;
  308. }
  309. static size_t
  310. sym_getSigningKeyLength_sp_basic128rsa15(const UA_SecurityPolicy *const securityPolicy,
  311. const void *const channelContext) {
  312. return UA_BASIC128RSA15_SYM_SIGNING_KEY_LENGTH;
  313. }
  314. static size_t
  315. sym_getEncryptionKeyLength_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  316. const void *channelContext) {
  317. return UA_SECURITYPOLICY_BASIC128RSA15_SYM_KEY_LENGTH;
  318. }
  319. static size_t
  320. sym_getEncryptionBlockSize_sp_basic128rsa15(const UA_SecurityPolicy *const securityPolicy,
  321. const void *const channelContext) {
  322. return UA_SECURITYPOLICY_BASIC128RSA15_SYM_ENCRYPTION_BLOCK_SIZE;
  323. }
  324. static size_t
  325. sym_getPlainTextBlockSize_sp_basic128rsa15(const UA_SecurityPolicy *const securityPolicy,
  326. const void *const channelContext) {
  327. return UA_SECURITYPOLICY_BASIC128RSA15_SYM_PLAIN_TEXT_BLOCK_SIZE;
  328. }
  329. static UA_StatusCode
  330. sym_encrypt_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  331. const Basic128Rsa15_ChannelContext *cc,
  332. UA_ByteString *data) {
  333. if(securityPolicy == NULL || cc == NULL || data == NULL)
  334. return UA_STATUSCODE_BADINTERNALERROR;
  335. if(cc->localSymIv.length !=
  336. securityPolicy->symmetricModule.cryptoModule.encryptionAlgorithm.getLocalBlockSize(securityPolicy, cc))
  337. return UA_STATUSCODE_BADINTERNALERROR;
  338. size_t plainTextBlockSize =
  339. securityPolicy->symmetricModule.cryptoModule.encryptionAlgorithm.getLocalPlainTextBlockSize(securityPolicy, cc);
  340. if(data->length % plainTextBlockSize != 0) {
  341. UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY,
  342. "Length of data to encrypt is not a multiple of the plain text block size."
  343. "Padding might not have been calculated appropriately.");
  344. return UA_STATUSCODE_BADINTERNALERROR;
  345. }
  346. /* Keylength in bits */
  347. unsigned int keylength = (unsigned int)(cc->localSymEncryptingKey.length * 8);
  348. mbedtls_aes_context aesContext;
  349. int mbedErr = mbedtls_aes_setkey_enc(&aesContext, cc->localSymEncryptingKey.data, keylength);
  350. UA_MBEDTLS_ERRORHANDLING_RETURN(UA_STATUSCODE_BADINTERNALERROR);
  351. UA_ByteString ivCopy;
  352. UA_StatusCode retval = UA_ByteString_copy(&cc->localSymIv, &ivCopy);
  353. if(retval != UA_STATUSCODE_GOOD)
  354. return retval;
  355. mbedErr = mbedtls_aes_crypt_cbc(&aesContext, MBEDTLS_AES_ENCRYPT, data->length,
  356. ivCopy.data, data->data, data->data);
  357. UA_MBEDTLS_ERRORHANDLING(UA_STATUSCODE_BADINTERNALERROR);
  358. UA_ByteString_deleteMembers(&ivCopy);
  359. return retval;
  360. }
  361. static UA_StatusCode
  362. sym_decrypt_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  363. const Basic128Rsa15_ChannelContext *cc,
  364. UA_ByteString *data) {
  365. if(securityPolicy == NULL || cc == NULL || data == NULL)
  366. return UA_STATUSCODE_BADINTERNALERROR;
  367. size_t encryptionBlockSize =
  368. securityPolicy->symmetricModule.cryptoModule.encryptionAlgorithm.getLocalBlockSize(securityPolicy, cc);
  369. if(cc->remoteSymIv.length != encryptionBlockSize)
  370. return UA_STATUSCODE_BADINTERNALERROR;
  371. if(data->length % encryptionBlockSize != 0) {
  372. UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY,
  373. "Length of data to decrypt is not a multiple of the encryptingBlock size.");
  374. return UA_STATUSCODE_BADINTERNALERROR;
  375. }
  376. unsigned int keylength = (unsigned int)(cc->remoteSymEncryptingKey.length * 8);
  377. mbedtls_aes_context aesContext;
  378. int mbedErr = mbedtls_aes_setkey_dec(&aesContext, cc->remoteSymEncryptingKey.data, keylength);
  379. UA_MBEDTLS_ERRORHANDLING_RETURN(UA_STATUSCODE_BADINTERNALERROR);
  380. UA_ByteString ivCopy;
  381. UA_StatusCode retval = UA_ByteString_copy(&cc->remoteSymIv, &ivCopy);
  382. if(retval != UA_STATUSCODE_GOOD)
  383. return retval;
  384. mbedErr = mbedtls_aes_crypt_cbc(&aesContext, MBEDTLS_AES_DECRYPT, data->length,
  385. ivCopy.data, data->data, data->data);
  386. UA_MBEDTLS_ERRORHANDLING(UA_STATUSCODE_BADINTERNALERROR);
  387. UA_ByteString_deleteMembers(&ivCopy);
  388. return retval;
  389. }
  390. static void
  391. swapBuffers(UA_ByteString *const bufA, UA_ByteString *const bufB) {
  392. UA_ByteString tmp = *bufA;
  393. *bufA = *bufB;
  394. *bufB = tmp;
  395. }
  396. static UA_StatusCode
  397. sym_generateKey_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  398. const UA_ByteString *secret, const UA_ByteString *seed,
  399. UA_ByteString *out) {
  400. if(securityPolicy == NULL || secret == NULL || seed == NULL || out == NULL)
  401. return UA_STATUSCODE_BADINTERNALERROR;
  402. Basic128Rsa15_PolicyContext *pc =
  403. (Basic128Rsa15_PolicyContext *)securityPolicy->policyContext;
  404. size_t hashLen = 0;
  405. const mbedtls_md_info_t *mdInfo = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1);
  406. hashLen = (size_t)mbedtls_md_get_size(mdInfo);
  407. UA_ByteString A_and_seed;
  408. UA_ByteString_allocBuffer(&A_and_seed, hashLen + seed->length);
  409. memcpy(A_and_seed.data + hashLen, seed->data, seed->length);
  410. UA_ByteString ANext_and_seed;
  411. UA_ByteString_allocBuffer(&ANext_and_seed, hashLen + seed->length);
  412. memcpy(ANext_and_seed.data + hashLen, seed->data, seed->length);
  413. UA_ByteString A = {
  414. hashLen,
  415. A_and_seed.data
  416. };
  417. UA_ByteString ANext = {
  418. hashLen,
  419. ANext_and_seed.data
  420. };
  421. md_hmac(&pc->sha1MdContext, secret, seed, A.data);
  422. UA_StatusCode retval = 0;
  423. for(size_t offset = 0; offset < out->length; offset += hashLen) {
  424. UA_ByteString outSegment = {
  425. hashLen,
  426. out->data + offset
  427. };
  428. UA_Boolean bufferAllocated = UA_FALSE;
  429. // Not enough room in out buffer to write the hash.
  430. if(offset + hashLen > out->length) {
  431. outSegment.data = NULL;
  432. outSegment.length = 0;
  433. retval = UA_ByteString_allocBuffer(&outSegment, hashLen);
  434. if(retval != UA_STATUSCODE_GOOD) {
  435. UA_ByteString_deleteMembers(&A_and_seed);
  436. UA_ByteString_deleteMembers(&ANext_and_seed);
  437. return retval;
  438. }
  439. bufferAllocated = UA_TRUE;
  440. }
  441. md_hmac(&pc->sha1MdContext, secret, &A_and_seed, outSegment.data);
  442. md_hmac(&pc->sha1MdContext, secret, &A, ANext.data);
  443. if(retval != UA_STATUSCODE_GOOD) {
  444. if(bufferAllocated)
  445. UA_ByteString_deleteMembers(&outSegment);
  446. UA_ByteString_deleteMembers(&A_and_seed);
  447. UA_ByteString_deleteMembers(&ANext_and_seed);
  448. return retval;
  449. }
  450. if(bufferAllocated) {
  451. memcpy(out->data + offset, outSegment.data, out->length - offset);
  452. UA_ByteString_deleteMembers(&outSegment);
  453. }
  454. swapBuffers(&ANext_and_seed, &A_and_seed);
  455. swapBuffers(&ANext, &A);
  456. }
  457. UA_ByteString_deleteMembers(&A_and_seed);
  458. UA_ByteString_deleteMembers(&ANext_and_seed);
  459. return UA_STATUSCODE_GOOD;
  460. }
  461. static UA_StatusCode
  462. sym_generateNonce_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  463. UA_ByteString *out) {
  464. if(securityPolicy == NULL || securityPolicy->policyContext == NULL || out == NULL)
  465. return UA_STATUSCODE_BADINTERNALERROR;
  466. Basic128Rsa15_PolicyContext *data =
  467. (Basic128Rsa15_PolicyContext *)securityPolicy->policyContext;
  468. int mbedErr = mbedtls_ctr_drbg_random(&data->drbgContext, out->data, out->length);
  469. UA_MBEDTLS_ERRORHANDLING_RETURN(UA_STATUSCODE_BADUNEXPECTEDERROR);
  470. return UA_STATUSCODE_GOOD;
  471. }
  472. /*****************/
  473. /* ChannelModule */
  474. /*****************/
  475. /* Assumes that the certificate has been verified externally */
  476. static UA_StatusCode
  477. parseRemoteCertificate_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc,
  478. const UA_ByteString *remoteCertificate) {
  479. if(remoteCertificate == NULL || cc == NULL)
  480. return UA_STATUSCODE_BADINTERNALERROR;
  481. const UA_SecurityPolicy *securityPolicy = cc->policyContext->securityPolicy;
  482. /* Parse the certificate */
  483. int mbedErr = mbedtls_x509_crt_parse(&cc->remoteCertificate, remoteCertificate->data,
  484. remoteCertificate->length);
  485. UA_MBEDTLS_ERRORHANDLING_RETURN(UA_STATUSCODE_BADSECURITYCHECKSFAILED);
  486. /* Check the key length */
  487. mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk);
  488. if(rsaContext->len < UA_SECURITYPOLICY_BASIC128RSA15_MINASYMKEYLENGTH ||
  489. rsaContext->len > UA_SECURITYPOLICY_BASIC128RSA15_MAXASYMKEYLENGTH)
  490. return UA_STATUSCODE_BADCERTIFICATEUSENOTALLOWED;
  491. return UA_STATUSCODE_GOOD;
  492. }
  493. static void
  494. channelContext_deleteContext_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc) {
  495. UA_ByteString_deleteMembers(&cc->localSymSigningKey);
  496. UA_ByteString_deleteMembers(&cc->localSymEncryptingKey);
  497. UA_ByteString_deleteMembers(&cc->localSymIv);
  498. UA_ByteString_deleteMembers(&cc->remoteSymSigningKey);
  499. UA_ByteString_deleteMembers(&cc->remoteSymEncryptingKey);
  500. UA_ByteString_deleteMembers(&cc->remoteSymIv);
  501. mbedtls_x509_crt_free(&cc->remoteCertificate);
  502. UA_free(cc);
  503. }
  504. static UA_StatusCode
  505. channelContext_newContext_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy,
  506. const UA_ByteString *remoteCertificate,
  507. void **pp_contextData) {
  508. if(securityPolicy == NULL || remoteCertificate == NULL || pp_contextData == NULL)
  509. return UA_STATUSCODE_BADINTERNALERROR;
  510. /* Allocate the channel context */
  511. *pp_contextData = UA_malloc(sizeof(Basic128Rsa15_ChannelContext));
  512. if(*pp_contextData == NULL)
  513. return UA_STATUSCODE_BADOUTOFMEMORY;
  514. Basic128Rsa15_ChannelContext *cc = (Basic128Rsa15_ChannelContext *)*pp_contextData;
  515. /* Initialize the channel context */
  516. cc->policyContext = (Basic128Rsa15_PolicyContext *)securityPolicy->policyContext;
  517. UA_ByteString_init(&cc->localSymSigningKey);
  518. UA_ByteString_init(&cc->localSymEncryptingKey);
  519. UA_ByteString_init(&cc->localSymIv);
  520. UA_ByteString_init(&cc->remoteSymSigningKey);
  521. UA_ByteString_init(&cc->remoteSymEncryptingKey);
  522. UA_ByteString_init(&cc->remoteSymIv);
  523. mbedtls_x509_crt_init(&cc->remoteCertificate);
  524. // TODO: this can be optimized so that we dont allocate memory before parsing the certificate
  525. UA_StatusCode retval = parseRemoteCertificate_sp_basic128rsa15(cc, remoteCertificate);
  526. if(retval != UA_STATUSCODE_GOOD) {
  527. channelContext_deleteContext_sp_basic128rsa15(cc);
  528. *pp_contextData = NULL;
  529. }
  530. return retval;
  531. }
  532. static UA_StatusCode
  533. channelContext_setLocalSymEncryptingKey_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc,
  534. const UA_ByteString *key) {
  535. if(key == NULL || cc == NULL)
  536. return UA_STATUSCODE_BADINTERNALERROR;
  537. UA_ByteString_deleteMembers(&cc->localSymEncryptingKey);
  538. return UA_ByteString_copy(key, &cc->localSymEncryptingKey);
  539. }
  540. static UA_StatusCode
  541. channelContext_setLocalSymSigningKey_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc,
  542. const UA_ByteString *key) {
  543. if(key == NULL || cc == NULL)
  544. return UA_STATUSCODE_BADINTERNALERROR;
  545. UA_ByteString_deleteMembers(&cc->localSymSigningKey);
  546. return UA_ByteString_copy(key, &cc->localSymSigningKey);
  547. }
  548. static UA_StatusCode
  549. channelContext_setLocalSymIv_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc,
  550. const UA_ByteString *iv) {
  551. if(iv == NULL || cc == NULL)
  552. return UA_STATUSCODE_BADINTERNALERROR;
  553. UA_ByteString_deleteMembers(&cc->localSymIv);
  554. return UA_ByteString_copy(iv, &cc->localSymIv);
  555. }
  556. static UA_StatusCode
  557. channelContext_setRemoteSymEncryptingKey_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc,
  558. const UA_ByteString *key) {
  559. if(key == NULL || cc == NULL)
  560. return UA_STATUSCODE_BADINTERNALERROR;
  561. UA_ByteString_deleteMembers(&cc->remoteSymEncryptingKey);
  562. return UA_ByteString_copy(key, &cc->remoteSymEncryptingKey);
  563. }
  564. static UA_StatusCode
  565. channelContext_setRemoteSymSigningKey_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc,
  566. const UA_ByteString *key) {
  567. if(key == NULL || cc == NULL)
  568. return UA_STATUSCODE_BADINTERNALERROR;
  569. UA_ByteString_deleteMembers(&cc->remoteSymSigningKey);
  570. return UA_ByteString_copy(key, &cc->remoteSymSigningKey);
  571. }
  572. static UA_StatusCode
  573. channelContext_setRemoteSymIv_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc,
  574. const UA_ByteString *iv) {
  575. if(iv == NULL || cc == NULL)
  576. return UA_STATUSCODE_BADINTERNALERROR;
  577. UA_ByteString_deleteMembers(&cc->remoteSymIv);
  578. return UA_ByteString_copy(iv, &cc->remoteSymIv);
  579. }
  580. static UA_StatusCode
  581. channelContext_compareCertificate_sp_basic128rsa15(const Basic128Rsa15_ChannelContext *cc,
  582. const UA_ByteString *certificate) {
  583. if(cc == NULL || certificate == NULL)
  584. return UA_STATUSCODE_BADINTERNALERROR;
  585. const UA_SecurityPolicy *securityPolicy = cc->policyContext->securityPolicy;
  586. mbedtls_x509_crt cert;
  587. mbedtls_x509_crt_init(&cert);
  588. int mbedErr = mbedtls_x509_crt_parse(&cert, certificate->data, certificate->length);
  589. if(mbedErr) {
  590. UA_LOG_MBEDERR;
  591. return UA_STATUSCODE_BADSECURITYCHECKSFAILED;
  592. }
  593. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  594. if(cert.raw.len != cc->remoteCertificate.raw.len ||
  595. memcmp(cert.raw.p, cc->remoteCertificate.raw.p, cert.raw.len) != 0)
  596. retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED;
  597. mbedtls_x509_crt_free(&cert);
  598. return retval;
  599. }
  600. static void
  601. deleteMembers_sp_basic128rsa15(UA_SecurityPolicy *securityPolicy) {
  602. if(securityPolicy == NULL)
  603. return;
  604. if(securityPolicy->policyContext == NULL)
  605. return;
  606. UA_ByteString_deleteMembers(&securityPolicy->localCertificate);
  607. /* delete all allocated members in the context */
  608. Basic128Rsa15_PolicyContext *pc = (Basic128Rsa15_PolicyContext *)
  609. securityPolicy->policyContext;
  610. mbedtls_ctr_drbg_free(&pc->drbgContext);
  611. mbedtls_entropy_free(&pc->entropyContext);
  612. mbedtls_pk_free(&pc->localPrivateKey);
  613. mbedtls_md_free(&pc->sha1MdContext);
  614. UA_ByteString_deleteMembers(&pc->localCertThumbprint);
  615. UA_LOG_DEBUG(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY,
  616. "Deleted members of EndpointContext for sp_basic128rsa15");
  617. UA_free(pc);
  618. securityPolicy->policyContext = NULL;
  619. }
  620. static UA_StatusCode
  621. updateCertificateAndPrivateKey_sp_basic128rsa15(UA_SecurityPolicy *securityPolicy,
  622. const UA_ByteString newCertificate,
  623. const UA_ByteString newPrivateKey) {
  624. if(securityPolicy == NULL)
  625. return UA_STATUSCODE_BADINTERNALERROR;
  626. if(securityPolicy->policyContext == NULL)
  627. return UA_STATUSCODE_BADINTERNALERROR;
  628. Basic128Rsa15_PolicyContext *pc = (Basic128Rsa15_PolicyContext *)securityPolicy->policyContext;
  629. UA_ByteString_deleteMembers(&securityPolicy->localCertificate);
  630. UA_StatusCode retval = UA_ByteString_allocBuffer(&securityPolicy->localCertificate, newCertificate.length + 1);
  631. if(retval != UA_STATUSCODE_GOOD)
  632. return retval;
  633. memcpy(securityPolicy->localCertificate.data, newCertificate.data, newCertificate.length);
  634. securityPolicy->localCertificate.data[newCertificate.length] = '\0';
  635. securityPolicy->localCertificate.length--;
  636. /* Set the new private key */
  637. mbedtls_pk_free(&pc->localPrivateKey);
  638. mbedtls_pk_init(&pc->localPrivateKey);
  639. int mbedErr = mbedtls_pk_parse_key(&pc->localPrivateKey,
  640. newPrivateKey.data, newPrivateKey.length,
  641. NULL, 0);
  642. UA_MBEDTLS_ERRORHANDLING(UA_STATUSCODE_BADSECURITYCHECKSFAILED);
  643. if(retval != UA_STATUSCODE_GOOD)
  644. goto error;
  645. retval = asym_makeThumbprint_sp_basic128rsa15(pc->securityPolicy,
  646. &securityPolicy->localCertificate,
  647. &pc->localCertThumbprint);
  648. if(retval != UA_STATUSCODE_GOOD)
  649. goto error;
  650. return retval;
  651. error:
  652. UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY,
  653. "Could not update certificate and private key");
  654. if(securityPolicy->policyContext != NULL)
  655. deleteMembers_sp_basic128rsa15(securityPolicy);
  656. return retval;
  657. }
  658. static UA_StatusCode
  659. policyContext_newContext_sp_basic128rsa15(UA_SecurityPolicy *securityPolicy,
  660. const UA_ByteString localPrivateKey) {
  661. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  662. if(securityPolicy == NULL)
  663. return UA_STATUSCODE_BADINTERNALERROR;
  664. Basic128Rsa15_PolicyContext *pc = (Basic128Rsa15_PolicyContext *)
  665. UA_malloc(sizeof(Basic128Rsa15_PolicyContext));
  666. securityPolicy->policyContext = (void *)pc;
  667. if(!pc) {
  668. retval = UA_STATUSCODE_BADOUTOFMEMORY;
  669. goto error;
  670. }
  671. /* Initialize the PolicyContext */
  672. memset(pc, 0, sizeof(Basic128Rsa15_PolicyContext));
  673. mbedtls_ctr_drbg_init(&pc->drbgContext);
  674. mbedtls_entropy_init(&pc->entropyContext);
  675. mbedtls_pk_init(&pc->localPrivateKey);
  676. mbedtls_md_init(&pc->sha1MdContext);
  677. pc->securityPolicy = securityPolicy;
  678. /* Initialized the message digest */
  679. const mbedtls_md_info_t *const mdInfo = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1);
  680. int mbedErr = mbedtls_md_setup(&pc->sha1MdContext, mdInfo, MBEDTLS_MD_SHA1);
  681. UA_MBEDTLS_ERRORHANDLING(UA_STATUSCODE_BADOUTOFMEMORY);
  682. if(retval != UA_STATUSCODE_GOOD)
  683. goto error;
  684. /* Add the system entropy source */
  685. mbedErr = mbedtls_entropy_add_source(&pc->entropyContext,
  686. mbedtls_platform_entropy_poll, NULL, 0,
  687. MBEDTLS_ENTROPY_SOURCE_STRONG);
  688. UA_MBEDTLS_ERRORHANDLING(UA_STATUSCODE_BADSECURITYCHECKSFAILED);
  689. if(retval != UA_STATUSCODE_GOOD)
  690. goto error;
  691. /* Seed the RNG */
  692. char *personalization = "open62541-drbg";
  693. mbedErr = mbedtls_ctr_drbg_seed(&pc->drbgContext, mbedtls_entropy_func,
  694. &pc->entropyContext,
  695. (const unsigned char *)personalization, 14);
  696. UA_MBEDTLS_ERRORHANDLING(UA_STATUSCODE_BADSECURITYCHECKSFAILED);
  697. if(retval != UA_STATUSCODE_GOOD)
  698. goto error;
  699. /* Set the private key */
  700. mbedErr = mbedtls_pk_parse_key(&pc->localPrivateKey,
  701. localPrivateKey.data, localPrivateKey.length,
  702. NULL, 0);
  703. UA_MBEDTLS_ERRORHANDLING(UA_STATUSCODE_BADSECURITYCHECKSFAILED);
  704. if(retval != UA_STATUSCODE_GOOD)
  705. goto error;
  706. /* Set the local certificate thumbprint */
  707. retval = UA_ByteString_allocBuffer(&pc->localCertThumbprint, UA_SHA1_LENGTH);
  708. if(retval != UA_STATUSCODE_GOOD)
  709. goto error;
  710. retval = asym_makeThumbprint_sp_basic128rsa15(pc->securityPolicy,
  711. &securityPolicy->localCertificate,
  712. &pc->localCertThumbprint);
  713. if(retval != UA_STATUSCODE_GOOD)
  714. goto error;
  715. return UA_STATUSCODE_GOOD;
  716. error:
  717. UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY,
  718. "Could not create securityContext");
  719. if(securityPolicy->policyContext != NULL)
  720. deleteMembers_sp_basic128rsa15(securityPolicy);
  721. return retval;
  722. }
  723. UA_StatusCode
  724. UA_SecurityPolicy_Basic128Rsa15(UA_SecurityPolicy *policy,
  725. UA_CertificateVerification *certificateVerification,
  726. const UA_ByteString localCertificate,
  727. const UA_ByteString localPrivateKey, const UA_Logger *logger) {
  728. memset(policy, 0, sizeof(UA_SecurityPolicy));
  729. policy->logger = logger;
  730. policy->policyUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#Basic128Rsa15");
  731. UA_SecurityPolicyAsymmetricModule *const asymmetricModule = &policy->asymmetricModule;
  732. UA_SecurityPolicySymmetricModule *const symmetricModule = &policy->symmetricModule;
  733. UA_SecurityPolicyChannelModule *const channelModule = &policy->channelModule;
  734. /* Copy the certificate and add a NULL to the end */
  735. UA_StatusCode retval =
  736. UA_ByteString_allocBuffer(&policy->localCertificate, localCertificate.length + 1);
  737. if(retval != UA_STATUSCODE_GOOD)
  738. return retval;
  739. memcpy(policy->localCertificate.data, localCertificate.data, localCertificate.length);
  740. policy->localCertificate.data[localCertificate.length] = '\0';
  741. policy->localCertificate.length--;
  742. policy->certificateVerification = certificateVerification;
  743. /* AsymmetricModule */
  744. UA_SecurityPolicySignatureAlgorithm *asym_signatureAlgorithm =
  745. &asymmetricModule->cryptoModule.signatureAlgorithm;
  746. asym_signatureAlgorithm->uri =
  747. UA_STRING("http://www.w3.org/2000/09/xmldsig#rsa-sha1\0");
  748. asym_signatureAlgorithm->verify =
  749. (UA_StatusCode (*)(const UA_SecurityPolicy *, void *,
  750. const UA_ByteString *, const UA_ByteString *))asym_verify_sp_basic128rsa15;
  751. asym_signatureAlgorithm->sign =
  752. (UA_StatusCode (*)(const UA_SecurityPolicy *, void *,
  753. const UA_ByteString *, UA_ByteString *))asym_sign_sp_basic128rsa15;
  754. asym_signatureAlgorithm->getLocalSignatureSize =
  755. (size_t (*)(const UA_SecurityPolicy *, const void *))asym_getLocalSignatureSize_sp_basic128rsa15;
  756. asym_signatureAlgorithm->getRemoteSignatureSize =
  757. (size_t (*)(const UA_SecurityPolicy *, const void *))asym_getRemoteSignatureSize_sp_basic128rsa15;
  758. asym_signatureAlgorithm->getLocalKeyLength = NULL; // TODO: Write function
  759. asym_signatureAlgorithm->getRemoteKeyLength = NULL; // TODO: Write function
  760. UA_SecurityPolicyEncryptionAlgorithm *asym_encryptionAlgorithm =
  761. &asymmetricModule->cryptoModule.encryptionAlgorithm;
  762. asym_encryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#rsa-1_5");
  763. asym_encryptionAlgorithm->encrypt =
  764. (UA_StatusCode(*)(const UA_SecurityPolicy *, void *, UA_ByteString *))asym_encrypt_sp_basic128rsa15;
  765. asym_encryptionAlgorithm->decrypt =
  766. (UA_StatusCode(*)(const UA_SecurityPolicy *, void *, UA_ByteString *))
  767. asym_decrypt_sp_basic128rsa15;
  768. asym_encryptionAlgorithm->getLocalKeyLength = NULL; // TODO: Write function
  769. asym_encryptionAlgorithm->getRemoteKeyLength =
  770. (size_t (*)(const UA_SecurityPolicy *, const void *))asym_getRemoteEncryptionKeyLength_sp_basic128rsa15;
  771. asym_encryptionAlgorithm->getLocalBlockSize = NULL; // TODO: Write function
  772. asym_encryptionAlgorithm->getRemoteBlockSize = (size_t (*)(const UA_SecurityPolicy *,
  773. const void *))asym_getRemoteBlockSize_sp_basic128rsa15;
  774. asym_encryptionAlgorithm->getLocalPlainTextBlockSize = NULL; // TODO: Write function
  775. asym_encryptionAlgorithm->getRemotePlainTextBlockSize =
  776. (size_t (*)(const UA_SecurityPolicy *, const void *))asym_getRemotePlainTextBlockSize_sp_basic128rsa15;
  777. asymmetricModule->makeCertificateThumbprint = asym_makeThumbprint_sp_basic128rsa15;
  778. asymmetricModule->compareCertificateThumbprint =
  779. asymmetricModule_compareCertificateThumbprint_sp_basic128rsa15;
  780. /* SymmetricModule */
  781. symmetricModule->generateKey = sym_generateKey_sp_basic128rsa15;
  782. symmetricModule->generateNonce = sym_generateNonce_sp_basic128rsa15;
  783. UA_SecurityPolicySignatureAlgorithm *sym_signatureAlgorithm =
  784. &symmetricModule->cryptoModule.signatureAlgorithm;
  785. sym_signatureAlgorithm->uri =
  786. UA_STRING("http://www.w3.org/2000/09/xmldsig#hmac-sha1\0");
  787. sym_signatureAlgorithm->verify =
  788. (UA_StatusCode (*)(const UA_SecurityPolicy *, void *, const UA_ByteString *,
  789. const UA_ByteString *))sym_verify_sp_basic128rsa15;
  790. sym_signatureAlgorithm->sign =
  791. (UA_StatusCode (*)(const UA_SecurityPolicy *, void *,
  792. const UA_ByteString *, UA_ByteString *))sym_sign_sp_basic128rsa15;
  793. sym_signatureAlgorithm->getLocalSignatureSize = sym_getSignatureSize_sp_basic128rsa15;
  794. sym_signatureAlgorithm->getRemoteSignatureSize = sym_getSignatureSize_sp_basic128rsa15;
  795. sym_signatureAlgorithm->getLocalKeyLength =
  796. (size_t (*)(const UA_SecurityPolicy *,
  797. const void *))sym_getSigningKeyLength_sp_basic128rsa15;
  798. sym_signatureAlgorithm->getRemoteKeyLength =
  799. (size_t (*)(const UA_SecurityPolicy *,
  800. const void *))sym_getSigningKeyLength_sp_basic128rsa15;
  801. UA_SecurityPolicyEncryptionAlgorithm *sym_encryptionAlgorithm =
  802. &symmetricModule->cryptoModule.encryptionAlgorithm;
  803. sym_encryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#aes128-cbc");
  804. sym_encryptionAlgorithm->encrypt =
  805. (UA_StatusCode(*)(const UA_SecurityPolicy *, void *, UA_ByteString *))sym_encrypt_sp_basic128rsa15;
  806. sym_encryptionAlgorithm->decrypt =
  807. (UA_StatusCode(*)(const UA_SecurityPolicy *, void *, UA_ByteString *))sym_decrypt_sp_basic128rsa15;
  808. sym_encryptionAlgorithm->getLocalKeyLength = sym_getEncryptionKeyLength_sp_basic128rsa15;
  809. sym_encryptionAlgorithm->getRemoteKeyLength = sym_getEncryptionKeyLength_sp_basic128rsa15;
  810. sym_encryptionAlgorithm->getLocalBlockSize =
  811. (size_t (*)(const UA_SecurityPolicy *, const void *))sym_getEncryptionBlockSize_sp_basic128rsa15;
  812. sym_encryptionAlgorithm->getRemoteBlockSize =
  813. (size_t (*)(const UA_SecurityPolicy *, const void *))sym_getEncryptionBlockSize_sp_basic128rsa15;
  814. sym_encryptionAlgorithm->getLocalPlainTextBlockSize =
  815. (size_t (*)(const UA_SecurityPolicy *, const void *))sym_getPlainTextBlockSize_sp_basic128rsa15;
  816. sym_encryptionAlgorithm->getRemotePlainTextBlockSize =
  817. (size_t (*)(const UA_SecurityPolicy *, const void *))sym_getPlainTextBlockSize_sp_basic128rsa15;
  818. symmetricModule->secureChannelNonceLength = 16;
  819. // Use the same signature algorithm as the asymmetric component for certificate signing (see standard)
  820. policy->certificateSigningAlgorithm = policy->asymmetricModule.cryptoModule.signatureAlgorithm;
  821. /* ChannelModule */
  822. channelModule->newContext = channelContext_newContext_sp_basic128rsa15;
  823. channelModule->deleteContext = (void (*)(void *))
  824. channelContext_deleteContext_sp_basic128rsa15;
  825. channelModule->setLocalSymEncryptingKey = (UA_StatusCode (*)(void *, const UA_ByteString *))
  826. channelContext_setLocalSymEncryptingKey_sp_basic128rsa15;
  827. channelModule->setLocalSymSigningKey = (UA_StatusCode (*)(void *, const UA_ByteString *))
  828. channelContext_setLocalSymSigningKey_sp_basic128rsa15;
  829. channelModule->setLocalSymIv = (UA_StatusCode (*)(void *, const UA_ByteString *))
  830. channelContext_setLocalSymIv_sp_basic128rsa15;
  831. channelModule->setRemoteSymEncryptingKey = (UA_StatusCode (*)(void *, const UA_ByteString *))
  832. channelContext_setRemoteSymEncryptingKey_sp_basic128rsa15;
  833. channelModule->setRemoteSymSigningKey = (UA_StatusCode (*)(void *, const UA_ByteString *))
  834. channelContext_setRemoteSymSigningKey_sp_basic128rsa15;
  835. channelModule->setRemoteSymIv = (UA_StatusCode (*)(void *, const UA_ByteString *))
  836. channelContext_setRemoteSymIv_sp_basic128rsa15;
  837. channelModule->compareCertificate = (UA_StatusCode (*)(const void *, const UA_ByteString *))
  838. channelContext_compareCertificate_sp_basic128rsa15;
  839. policy->updateCertificateAndPrivateKey = updateCertificateAndPrivateKey_sp_basic128rsa15;
  840. policy->deleteMembers = deleteMembers_sp_basic128rsa15;
  841. return policyContext_newContext_sp_basic128rsa15(policy, localPrivateKey);
  842. }