OpenSSL  1.0.1c
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros
example.c
Go to the documentation of this file.
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <openssl/pkcs7.h>
5 #include <openssl/asn1_mac.h>
6 #include <openssl/x509.h>
7 
8 int add_signed_time(PKCS7_SIGNER_INFO *si)
9  {
10  ASN1_UTCTIME *sign_time;
11 
12  /* The last parameter is the amount to add/subtract from the current
13  * time (in seconds) */
14  sign_time=X509_gmtime_adj(NULL,0);
15  PKCS7_add_signed_attribute(si,NID_pkcs9_signingTime,
16  V_ASN1_UTCTIME,(char *)sign_time);
17  return(1);
18  }
19 
20 ASN1_UTCTIME *get_signed_time(PKCS7_SIGNER_INFO *si)
21  {
22  ASN1_TYPE *so;
23 
24  so=PKCS7_get_signed_attribute(si,NID_pkcs9_signingTime);
25  if (so->type == V_ASN1_UTCTIME)
26  return so->value.utctime;
27  return NULL;
28  }
29 
30 static int signed_string_nid= -1;
31 
32 void add_signed_string(PKCS7_SIGNER_INFO *si, char *str)
33  {
34  ASN1_OCTET_STRING *os;
35 
36  /* To a an object of OID 1.2.3.4.5, which is an octet string */
37  if (signed_string_nid == -1)
38  signed_string_nid=
39  OBJ_create("1.2.3.4.5","OID_example","Our example OID");
40  os=ASN1_OCTET_STRING_new();
41  ASN1_OCTET_STRING_set(os,(unsigned char*)str,strlen(str));
42  /* When we add, we do not free */
43  PKCS7_add_signed_attribute(si,signed_string_nid,
44  V_ASN1_OCTET_STRING,(char *)os);
45  }
46 
47 int get_signed_string(PKCS7_SIGNER_INFO *si, char *buf, int len)
48  {
49  ASN1_TYPE *so;
50  ASN1_OCTET_STRING *os;
51  int i;
52 
53  if (signed_string_nid == -1)
54  signed_string_nid=
55  OBJ_create("1.2.3.4.5","OID_example","Our example OID");
56  /* To retrieve */
57  so=PKCS7_get_signed_attribute(si,signed_string_nid);
58  if (so != NULL)
59  {
60  if (so->type == V_ASN1_OCTET_STRING)
61  {
62  os=so->value.octet_string;
63  i=os->length;
64  if ((i+1) > len)
65  i=len-1;
66  memcpy(buf,os->data,i);
67  return(i);
68  }
69  }
70  return(0);
71  }
72 
73 static int signed_seq2string_nid= -1;
74 /* ########################################### */
75 int add_signed_seq2string(PKCS7_SIGNER_INFO *si, char *str1, char *str2)
76  {
77  /* To add an object of OID 1.9.999, which is a sequence containing
78  * 2 octet strings */
79  unsigned char *p;
80  ASN1_OCTET_STRING *os1,*os2;
81  ASN1_STRING *seq;
82  unsigned char *data;
83  int i,total;
84 
85  if (signed_seq2string_nid == -1)
86  signed_seq2string_nid=
87  OBJ_create("1.9.9999","OID_example","Our example OID");
88 
89  os1=ASN1_OCTET_STRING_new();
90  os2=ASN1_OCTET_STRING_new();
91  ASN1_OCTET_STRING_set(os1,(unsigned char*)str1,strlen(str1));
92  ASN1_OCTET_STRING_set(os2,(unsigned char*)str1,strlen(str1));
93  i =i2d_ASN1_OCTET_STRING(os1,NULL);
94  i+=i2d_ASN1_OCTET_STRING(os2,NULL);
95  total=ASN1_object_size(1,i,V_ASN1_SEQUENCE);
96 
97  data=malloc(total);
98  p=data;
99  ASN1_put_object(&p,1,i,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
100  i2d_ASN1_OCTET_STRING(os1,&p);
101  i2d_ASN1_OCTET_STRING(os2,&p);
102 
103  seq=ASN1_STRING_new();
104  ASN1_STRING_set(seq,data,total);
105  free(data);
106  ASN1_OCTET_STRING_free(os1);
107  ASN1_OCTET_STRING_free(os2);
108 
109  PKCS7_add_signed_attribute(si,signed_seq2string_nid,
110  V_ASN1_SEQUENCE,(char *)seq);
111  return(1);
112  }
113 
114 /* For this case, I will malloc the return strings */
115 int get_signed_seq2string(PKCS7_SIGNER_INFO *si, char **str1, char **str2)
116  {
117  ASN1_TYPE *so;
118 
119  if (signed_seq2string_nid == -1)
120  signed_seq2string_nid=
121  OBJ_create("1.9.9999","OID_example","Our example OID");
122  /* To retrieve */
123  so=PKCS7_get_signed_attribute(si,signed_seq2string_nid);
124  if (so && (so->type == V_ASN1_SEQUENCE))
125  {
126  ASN1_const_CTX c;
127  ASN1_STRING *s;
128  long length;
129  ASN1_OCTET_STRING *os1,*os2;
130 
131  s=so->value.sequence;
132  c.p=ASN1_STRING_data(s);
133  c.max=c.p+ASN1_STRING_length(s);
134  if (!asn1_GetSequence(&c,&length)) goto err;
135  /* Length is the length of the seqence */
136 
137  c.q=c.p;
138  if ((os1=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL)
139  goto err;
140  c.slen-=(c.p-c.q);
141 
142  c.q=c.p;
143  if ((os2=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL)
144  goto err;
145  c.slen-=(c.p-c.q);
146 
147  if (!asn1_const_Finish(&c)) goto err;
148  *str1=malloc(os1->length+1);
149  *str2=malloc(os2->length+1);
150  memcpy(*str1,os1->data,os1->length);
151  memcpy(*str2,os2->data,os2->length);
152  (*str1)[os1->length]='\0';
153  (*str2)[os2->length]='\0';
154  ASN1_OCTET_STRING_free(os1);
155  ASN1_OCTET_STRING_free(os2);
156  return(1);
157  }
158 err:
159  return(0);
160  }
161 
162 
163 /* #######################################
164  * THE OTHER WAY TO DO THINGS
165  * #######################################
166  */
167 X509_ATTRIBUTE *create_time(void)
168  {
169  ASN1_UTCTIME *sign_time;
170  X509_ATTRIBUTE *ret;
171 
172  /* The last parameter is the amount to add/subtract from the current
173  * time (in seconds) */
174  sign_time=X509_gmtime_adj(NULL,0);
175  ret=X509_ATTRIBUTE_create(NID_pkcs9_signingTime,
176  V_ASN1_UTCTIME,(char *)sign_time);
177  return(ret);
178  }
179 
180 ASN1_UTCTIME *sk_get_time(STACK_OF(X509_ATTRIBUTE) *sk)
181  {
182  ASN1_TYPE *so;
183  PKCS7_SIGNER_INFO si;
184 
185  si.auth_attr=sk;
186  so=PKCS7_get_signed_attribute(&si,NID_pkcs9_signingTime);
187  if (so->type == V_ASN1_UTCTIME)
188  return so->value.utctime;
189  return NULL;
190  }
191 
192 X509_ATTRIBUTE *create_string(char *str)
193  {
194  ASN1_OCTET_STRING *os;
195  X509_ATTRIBUTE *ret;
196 
197  /* To a an object of OID 1.2.3.4.5, which is an octet string */
198  if (signed_string_nid == -1)
199  signed_string_nid=
200  OBJ_create("1.2.3.4.5","OID_example","Our example OID");
201  os=ASN1_OCTET_STRING_new();
202  ASN1_OCTET_STRING_set(os,(unsigned char*)str,strlen(str));
203  /* When we add, we do not free */
204  ret=X509_ATTRIBUTE_create(signed_string_nid,
205  V_ASN1_OCTET_STRING,(char *)os);
206  return(ret);
207  }
208 
209 int sk_get_string(STACK_OF(X509_ATTRIBUTE) *sk, char *buf, int len)
210  {
211  ASN1_TYPE *so;
212  ASN1_OCTET_STRING *os;
213  int i;
214  PKCS7_SIGNER_INFO si;
215 
216  si.auth_attr=sk;
217 
218  if (signed_string_nid == -1)
219  signed_string_nid=
220  OBJ_create("1.2.3.4.5","OID_example","Our example OID");
221  /* To retrieve */
222  so=PKCS7_get_signed_attribute(&si,signed_string_nid);
223  if (so != NULL)
224  {
225  if (so->type == V_ASN1_OCTET_STRING)
226  {
227  os=so->value.octet_string;
228  i=os->length;
229  if ((i+1) > len)
230  i=len-1;
231  memcpy(buf,os->data,i);
232  return(i);
233  }
234  }
235  return(0);
236  }
237 
238 X509_ATTRIBUTE *add_seq2string(PKCS7_SIGNER_INFO *si, char *str1, char *str2)
239  {
240  /* To add an object of OID 1.9.999, which is a sequence containing
241  * 2 octet strings */
242  unsigned char *p;
243  ASN1_OCTET_STRING *os1,*os2;
244  ASN1_STRING *seq;
245  X509_ATTRIBUTE *ret;
246  unsigned char *data;
247  int i,total;
248 
249  if (signed_seq2string_nid == -1)
250  signed_seq2string_nid=
251  OBJ_create("1.9.9999","OID_example","Our example OID");
252 
253  os1=ASN1_OCTET_STRING_new();
254  os2=ASN1_OCTET_STRING_new();
255  ASN1_OCTET_STRING_set(os1,(unsigned char*)str1,strlen(str1));
256  ASN1_OCTET_STRING_set(os2,(unsigned char*)str1,strlen(str1));
257  i =i2d_ASN1_OCTET_STRING(os1,NULL);
258  i+=i2d_ASN1_OCTET_STRING(os2,NULL);
259  total=ASN1_object_size(1,i,V_ASN1_SEQUENCE);
260 
261  data=malloc(total);
262  p=data;
263  ASN1_put_object(&p,1,i,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
264  i2d_ASN1_OCTET_STRING(os1,&p);
265  i2d_ASN1_OCTET_STRING(os2,&p);
266 
267  seq=ASN1_STRING_new();
268  ASN1_STRING_set(seq,data,total);
269  free(data);
270  ASN1_OCTET_STRING_free(os1);
271  ASN1_OCTET_STRING_free(os2);
272 
273  ret=X509_ATTRIBUTE_create(signed_seq2string_nid,
274  V_ASN1_SEQUENCE,(char *)seq);
275  return(ret);
276  }
277 
278 /* For this case, I will malloc the return strings */
279 int sk_get_seq2string(STACK_OF(X509_ATTRIBUTE) *sk, char **str1, char **str2)
280  {
281  ASN1_TYPE *so;
282  PKCS7_SIGNER_INFO si;
283 
284  if (signed_seq2string_nid == -1)
285  signed_seq2string_nid=
286  OBJ_create("1.9.9999","OID_example","Our example OID");
287 
288  si.auth_attr=sk;
289  /* To retrieve */
290  so=PKCS7_get_signed_attribute(&si,signed_seq2string_nid);
291  if (so->type == V_ASN1_SEQUENCE)
292  {
293  ASN1_const_CTX c;
294  ASN1_STRING *s;
295  long length;
296  ASN1_OCTET_STRING *os1,*os2;
297 
298  s=so->value.sequence;
299  c.p=ASN1_STRING_data(s);
300  c.max=c.p+ASN1_STRING_length(s);
301  if (!asn1_GetSequence(&c,&length)) goto err;
302  /* Length is the length of the seqence */
303 
304  c.q=c.p;
305  if ((os1=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL)
306  goto err;
307  c.slen-=(c.p-c.q);
308 
309  c.q=c.p;
310  if ((os2=d2i_ASN1_OCTET_STRING(NULL,&c.p,c.slen)) == NULL)
311  goto err;
312  c.slen-=(c.p-c.q);
313 
314  if (!asn1_const_Finish(&c)) goto err;
315  *str1=malloc(os1->length+1);
316  *str2=malloc(os2->length+1);
317  memcpy(*str1,os1->data,os1->length);
318  memcpy(*str2,os2->data,os2->length);
319  (*str1)[os1->length]='\0';
320  (*str2)[os2->length]='\0';
321  ASN1_OCTET_STRING_free(os1);
322  ASN1_OCTET_STRING_free(os2);
323  return(1);
324  }
325 err:
326  return(0);
327  }
328 
329 
Generated on Thu Jan 10 2013 09:53:38 for OpenSSL by   doxygen 1.8.2