← Back to branch summary

~ubuntu-branches/ubuntu/raring/ipxe/raring

« back to all changes in this revision

Viewing changes to src/tests/pubkey_test.h

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2012-11-14 15:47:31 UTC
  • mfrom: (1.1.3)
  • Revision ID: package-import@ubuntu.com-20121114154731-jhuy5d1h2jw75qe9
Tags: 1.0.0+git-4.d6b0b76-0ubuntu1
https://launchpad.net/bugs/1025239
* New upstream snapshot:
  - d/p/iscsi*.patch: Dropped - included in snapshot.
  - Refreshed all other patches.
* d/p/enable-https.patch: Enable HTTPS support (LP: #1025239).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tests/pubkey_test.h
 
1
#ifndef _PUBKEY_TEST_H
 
2
#define _PUBKEY_TEST_H
 
3
 
 
4
FILE_LICENCE ( GPL2_OR_LATER );
 
5
 
 
6
#include <stdint.h>
 
7
#include <ipxe/crypto.h>
 
8
#include <ipxe/test.h>
 
9
 
 
10
/**
 
11
 * Report public key decryption test result
 
12
 *
 
13
 * @v pubkey            Public key algorithm
 
14
 * @v key               Key
 
15
 * @v key_len           Key length
 
16
 * @v ciphertext        Ciphertext
 
17
 * @v ciphertext_len    Ciphertext length
 
18
 * @v expected          Expected plaintext
 
19
 * @v expected_len      Expected plaintext length
 
20
 */
 
21
#define pubkey_decrypt_ok( pubkey, key, key_len, ciphertext,            \
 
22
                           ciphertext_len, expected, expected_len ) do {\
 
23
        uint8_t ctx[ (pubkey)->ctxsize ];                               \
 
24
                                                                        \
 
25
        ok ( pubkey_init ( (pubkey), ctx, (key), (key_len) ) == 0 );    \
 
26
        {                                                               \
 
27
                size_t max_len = pubkey_max_len ( (pubkey), ctx );      \
 
28
                uint8_t decrypted[ max_len ];                           \
 
29
                int decrypted_len;                                      \
 
30
                                                                        \
 
31
                decrypted_len = pubkey_decrypt ( (pubkey), ctx,         \
 
32
                                                 (ciphertext),          \
 
33
                                                 (ciphertext_len),      \
 
34
                                                 decrypted );           \
 
35
                ok ( decrypted_len == ( ( int ) (expected_len) ) );     \
 
36
                ok ( memcmp ( decrypted, (expected),                    \
 
37
                              (expected_len) ) == 0 );                  \
 
38
        }                                                               \
 
39
        pubkey_final ( (pubkey), ctx );                                 \
 
40
        } while ( 0 )
 
41
 
 
42
/**
 
43
 * Report public key encryption and decryption test result
 
44
 *
 
45
 * @v pubkey            Public key algorithm
 
46
 * @v encrypt_key       Encryption key
 
47
 * @v encrypt_key_len   Encryption key length
 
48
 * @v decrypt_key       Decryption key
 
49
 * @v decrypt_key_len   Decryption key length
 
50
 * @v plaintext         Plaintext
 
51
 * @v plaintext_len     Plaintext length
 
52
 */
 
53
#define pubkey_encrypt_ok( pubkey, encrypt_key, encrypt_key_len,        \
 
54
                           decrypt_key, decrypt_key_len, plaintext,     \
 
55
                           plaintext_len ) do {                         \
 
56
        uint8_t ctx[ (pubkey)->ctxsize ];                               \
 
57
                                                                        \
 
58
        ok ( pubkey_init ( (pubkey), ctx, (encrypt_key),                \
 
59
                           (encrypt_key_len) ) == 0 );                  \
 
60
        {                                                               \
 
61
                size_t max_len = pubkey_max_len ( (pubkey), ctx );      \
 
62
                uint8_t encrypted[ max_len ];                           \
 
63
                int encrypted_len;                                      \
 
64
                                                                        \
 
65
                encrypted_len = pubkey_encrypt ( (pubkey), ctx,         \
 
66
                                                 (plaintext),           \
 
67
                                                 (plaintext_len),       \
 
68
                                                 encrypted );           \
 
69
                ok ( encrypted_len >= 0 );                              \
 
70
                pubkey_decrypt_ok ( (pubkey), (decrypt_key),            \
 
71
                                    (decrypt_key_len), encrypted,       \
 
72
                                    encrypted_len, (plaintext),         \
 
73
                                    (plaintext_len) );                  \
 
74
        }                                                               \
 
75
        pubkey_final ( (pubkey), ctx );                                 \
 
76
        } while ( 0 )
 
77
 
 
78
/**
 
79
 * Report public key signature test result
 
80
 *
 
81
 * @v pubkey            Public key algorithm
 
82
 * @v key               Key
 
83
 * @v key_len           Key length
 
84
 * @v digest            Digest algorithm
 
85
 * @v plaintext         Plaintext
 
86
 * @v plaintext_len     Plaintext length
 
87
 * @v expected          Expected signature
 
88
 * @v expected_len      Expected signature length
 
89
 */
 
90
#define pubkey_sign_ok( pubkey, key, key_len, digest, plaintext,        \
 
91
                        plaintext_len, expected, expected_len ) do {    \
 
92
        uint8_t ctx[ (pubkey)->ctxsize ];                               \
 
93
        uint8_t digestctx[ (digest)->ctxsize ];                         \
 
94
        uint8_t digestout[ (digest)->digestsize ];                      \
 
95
                                                                        \
 
96
        digest_init ( (digest), digestctx );                            \
 
97
        digest_update ( (digest), digestctx, (plaintext),               \
 
98
                        (plaintext_len) );                              \
 
99
        digest_final ( (digest), digestctx, digestout );                \
 
100
                                                                        \
 
101
        ok ( pubkey_init ( (pubkey), ctx, (key), (key_len) ) == 0 );    \
 
102
        {                                                               \
 
103
                size_t max_len = pubkey_max_len ( (pubkey), ctx );      \
 
104
                uint8_t signature[ max_len ];                           \
 
105
                int signature_len;                                      \
 
106
                                                                        \
 
107
                signature_len = pubkey_sign ( (pubkey), ctx, (digest),  \
 
108
                                              digestout, signature );   \
 
109
                ok ( signature_len == ( ( int ) (expected_len) ) );     \
 
110
                ok ( memcmp ( signature, (expected),                    \
 
111
                              (expected_len) ) == 0 );                  \
 
112
        }                                                               \
 
113
        pubkey_final ( (pubkey), ctx );                                 \
 
114
        } while ( 0 )
 
115
 
 
116
/**
 
117
 * Report public key verification test result
 
118
 *
 
119
 * @v pubkey            Public key algorithm
 
120
 * @v key               Key
 
121
 * @v key_len           Key length
 
122
 * @v digest            Digest algorithm
 
123
 * @v plaintext         Plaintext
 
124
 * @v plaintext_len     Plaintext length
 
125
 * @v signature         Signature
 
126
 * @v signature_len     Signature length
 
127
 */
 
128
#define pubkey_verify_ok( pubkey, key, key_len, digest, plaintext,      \
 
129
                          plaintext_len, signature, signature_len ) do {\
 
130
        uint8_t ctx[ (pubkey)->ctxsize ];                               \
 
131
        uint8_t digestctx[ (digest)->ctxsize ];                         \
 
132
        uint8_t digestout[ (digest)->digestsize ];                      \
 
133
                                                                        \
 
134
        digest_init ( (digest), digestctx );                            \
 
135
        digest_update ( (digest), digestctx, (plaintext),               \
 
136
                        (plaintext_len) );                              \
 
137
        digest_final ( (digest), digestctx, digestout );                \
 
138
                                                                        \
 
139
        ok ( pubkey_init ( (pubkey), ctx, (key), (key_len) ) == 0 );    \
 
140
        ok ( pubkey_verify ( (pubkey), ctx, (digest), digestout,        \
 
141
                             (signature), (signature_len) ) == 0 );     \
 
142
        pubkey_final ( (pubkey), ctx );                                 \
 
143
        } while ( 0 )
 
144
 
 
145
/**
 
146
 * Report public key verification test result
 
147
 *
 
148
 * @v pubkey            Public key algorithm
 
149
 * @v key               Key
 
150
 * @v key_len           Key length
 
151
 * @v digest            Digest algorithm
 
152
 * @v plaintext         Plaintext
 
153
 * @v plaintext_len     Plaintext length
 
154
 * @v signature         Signature
 
155
 * @v signature_len     Signature length
 
156
 */
 
157
#define pubkey_verify_fail_ok( pubkey, key, key_len, digest, plaintext, \
 
158
                               plaintext_len, signature,                \
 
159
                               signature_len ) do {                     \
 
160
        uint8_t ctx[ (pubkey)->ctxsize ];                               \
 
161
        uint8_t digestctx[ (digest)->ctxsize ];                         \
 
162
        uint8_t digestout[ (digest)->digestsize ];                      \
 
163
                                                                        \
 
164
        digest_init ( (digest), digestctx );                            \
 
165
        digest_update ( (digest), digestctx, (plaintext),               \
 
166
                        (plaintext_len) );                              \
 
167
        digest_final ( (digest), digestctx, digestout );                \
 
168
                                                                        \
 
169
        ok ( pubkey_init ( (pubkey), ctx, (key), (key_len) ) == 0 );    \
 
170
        ok ( pubkey_verify ( (pubkey), ctx, (digest), digestout,        \
 
171
                             (signature), (signature_len) ) != 0 );     \
 
172
        pubkey_final ( (pubkey), ctx );                                 \
 
173
        } while ( 0 )
 
174
 
 
175
#endif /* _PUBKEY_TEST_H */