Spritz.xs

filter: Statementstmt 87.9% 51 / 58 Branchbran 50.0% 14 / 28 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 75.5% 65 / 86 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« spritz/spritz.h ↑ Summary spritz/spritz.c »
1 #include "EXTERN.h"
2 #include "perl.h"
3 #include "XSUB.h"
4  
5 #include "perlmulticore.h"
6  
7 #include "spritz/spritz.c"
8  
9 typedef spritz_state *Crypt__Spritz;
10 #if 0
11 typedef spritz_state *Crypt__Spritz__CIPHER;
12 typedef spritz_state *Crypt__Spritz__CIPHER__XOR;
13 typedef spritz_state *Crypt__Spritz__HASH;
14 typedef spritz_state *Crypt__Spritz__MAC;
15 typedef spritz_state *Crypt__Spritz__AEAD;
16 typedef spritz_state *Crypt__Spritz__AEAD__XOR;
17 #endif
18  
19 static SV *
20 262 alloc_pv (STRLEN len)
21 {
22 262 SV *r = newSV (len);
23  
24 262 sv_upgrade (r, SVt_PV);
25 262 SvCUR_set (r, len);
26 262 SvPOK_only (r);
27 262 *SvEND (r) = 0;
28  
29 262 return r;
30 }
31  
32 static SV *
33 91 alloc_state (SV *klass)
34 {
35 91 SV *r = alloc_pv (sizeof (spritz_state));
36  
37 91 return sv_bless (newRV_noinc (r), gv_stashsv (klass, GV_ADD));
38 }
39  
40 static spritz_state *
41 312 get_state (SV *sv)
42 {
43 312 ▶ if (!sv_derived_from (sv, "Crypt::Spritz::Base"))
Branch: 1 branch
BranchTrueFalseTotal
if (!sv_derived_from (sv, "Crypt::Spritz::Base")) 0 312 312
44 0 croak ("object is not of type Crypt::Spritz::Base");
45  
46 312 sv = SvRV (sv);
47  
48 /* this can happen when the objhetc is serialised, which isn't officially supported */
49 312 ▶ if (SvUTF8 (sv))
Branch: 1 branch
BranchTrueFalseTotal
if (SvUTF8 (sv)) 0 312 312
50 0 sv_utf8_downgrade (sv, 0);
51  
52 312 return (spritz_state *)SvPVX (sv);
53 }
54  
55 MODULE = Crypt::Spritz PACKAGE = Crypt::Spritz::Base
56  
57 SV *
58 clone (SV *self)
59 CODE:
60 /* no type check... too bad */
61 9 self = SvRV (self);
62 9 RETVAL = sv_bless (newRV_noinc (newSVsv (self)), SvSTASH (self));
63 OUTPUT:
64 RETVAL
65  
66 MODULE = Crypt::Spritz PACKAGE = Crypt::Spritz PREFIX = spritz_
67  
68 PROTOTYPES: ENABLE
69  
70 SV *
71 new (SV *klass)
72 CODE:
73 10 RETVAL = alloc_state (klass);
74 10 spritz_init ((spritz_state *)SvPVX (SvRV (RETVAL)));
75 OUTPUT:
76 RETVAL
77  
78 void spritz_init (Crypt::Spritz self)
79  
80 void spritz_update (Crypt::Spritz self)
81  
82 void spritz_whip (Crypt::Spritz self, UV r)
83  
84 void spritz_crush (Crypt::Spritz self)
85  
86 void spritz_shuffle (Crypt::Spritz self)
87  
88 void spritz_absorb_stop (Crypt::Spritz self)
89  
90 void spritz_absorb (Crypt::Spritz self, SV *data)
91 ALIAS:
92 absorb_and_stop = 1
93 CODE:
94 {
95 123 STRLEN len; char *ptr = SvPVbyte (data, len);
96  
97 123 ▶ if (len > 400) perlinterp_release ();
Branch: 1 branch
BranchTrueFalseTotal
if (len > 400) perlinterp_release (); 0 123 123
98  
99 123 spritz_absorb (self, ptr, len);
100  
101 123 ▶ if (ix)
Branch: 1 branch
BranchTrueFalseTotal
if (ix) 54 69 123
102 54 spritz_absorb_stop (self);
103  
104 123 ▶ if (len > 400) perlinterp_acquire ();
Branch: 1 branch
BranchTrueFalseTotal
if (len > 400) perlinterp_acquire (); 0 123 123
105 }
106  
107 U8 spritz_output (Crypt::Spritz self)
108  
109 U8 spritz_drip (Crypt::Spritz self)
110  
111 SV *
112 spritz_squeeze (Crypt::Spritz self, STRLEN len)
113 CODE:
114 90 RETVAL = alloc_pv (len);
115 90 spritz_squeeze (self, SvPVX (RETVAL), len);
116 OUTPUT:
117 RETVAL
118  
119 MODULE = Crypt::Spritz PACKAGE = Crypt::Spritz::Cipher PREFIX = spritz_cipher_xor_
120  
121 SV *
122 new (SV *klass, SV *K, SV *IV = 0)
123 CODE:
124 {
125 36 STRLEN k_len ; char *k = SvPVbyte (K , k_len );
126 36 ▶ STRLEN iv_len = 0; char *iv = IV ? SvPVbyte (IV, iv_len) : 0;
Branch: 1 branch
BranchTrueFalseTotal
STRLEN iv_len = 0; char *iv = IV ? SvPVbyte (IV, iv_len) : 0; 0 36 36
127 36 RETVAL = alloc_state (klass);
128 36 spritz_cipher_xor_init ((spritz_state *)SvPVX (SvRV (RETVAL)), k, k_len, iv, iv_len);
129 }
130 OUTPUT:
131 RETVAL
132  
133 MODULE = Crypt::Spritz PACKAGE = Crypt::Spritz::Cipher PREFIX = spritz_cipher_
134  
135 SV *
136 encrypt (Crypt::Spritz self, SV *I)
137 ALIAS:
138 encrypt = 0
139 decrypt = 1
140 Crypt::Spritz::Cipher::XOR::crypt = 2
141 Crypt::Spritz::AEAD::encrypt = 3
142 Crypt::Spritz::AEAD::decrypt = 4
143 Crypt::Spritz::AEAD::XOR::crypt = 5
144 CODE:
145 static void (*f[])(spritz_state *s, const void *I, void *O, size_t len) = {
146 spritz_cipher_encrypt,
147 spritz_cipher_decrypt,
148 spritz_cipher_xor_crypt,
149 spritz_aead_encrypt,
150 spritz_aead_decrypt,
151 spritz_aead_xor_crypt
152 };
153 {
154 54 STRLEN len; char *ptr = SvPVbyte (I, len);
155 char *retval;
156 54 ▶ STRLEN slow_len = ix < 3 ? 4000 : 400;
Branch: 1 branch
BranchTrueFalseTotal
STRLEN slow_len = ix < 3 ? 4000 : 400; 27 27 54
157 54 RETVAL = alloc_pv (len);
158 54 retval = SvPVX (RETVAL);
159 54 ▶ if (len > slow_len) perlinterp_release ();
Branch: 1 branch
BranchTrueFalseTotal
if (len > slow_len) perlinterp_release (); 0 54 54
160 54 f[ix](self, ptr, retval, len);
161 54 ▶ if (len > slow_len) perlinterp_acquire ();
Branch: 1 branch
BranchTrueFalseTotal
if (len > slow_len) perlinterp_acquire (); 0 54 54
162 }
163 OUTPUT:
164 RETVAL
165  
166 MODULE = Crypt::Spritz PACKAGE = Crypt::Spritz::Cipher::XOR PREFIX = spritz_cipher_xor_
167  
168 # crypt == Spritz::Cipher::crypt (xs-alias)
169  
170 void
171 crypt_inplace (Crypt::Spritz self, SV *I)
172 CODE:
173 9 sv_force_normal (I);
174 {
175 9 STRLEN len; char *ptr = SvPVbyte (I, len);
176 9 ▶ if (len > 4000) perlinterp_release ();
Branch: 1 branch
BranchTrueFalseTotal
if (len > 4000) perlinterp_release (); 0 9 9
177 9 spritz_cipher_xor_crypt (self, ptr, ptr, len);
178 9 ▶ if (len > 4000) perlinterp_acquire ();
Branch: 1 branch
BranchTrueFalseTotal
if (len > 4000) perlinterp_acquire (); 0 9 9
179 }
180  
181 MODULE = Crypt::Spritz PACKAGE = Crypt::Spritz::Hash PREFIX = spritz_hash_
182  
183 # new == Spritz::new (inherit)
184 # add == absorb (alias)
185  
186 SV *
187 spritz_hash_finish (Crypt::Spritz self, STRLEN len)
188 CODE:
189 char *retval;
190 27 RETVAL = alloc_pv (len);
191 27 spritz_hash_finish (self, SvPVX (RETVAL), len);
192 OUTPUT:
193 RETVAL
194  
195 MODULE = Crypt::Spritz PACKAGE = Crypt::Spritz::MAC PREFIX = spritz_mac_
196  
197 SV *
198 new (SV *klass, SV *K)
199 CODE:
200 {
201 36 STRLEN len; char *ptr = SvPVbyte (K, len);
202 36 RETVAL = alloc_state (klass);
203 36 spritz_mac_init ((spritz_state *)SvPVX (SvRV (RETVAL)), ptr, len);
204 }
205 OUTPUT:
206 RETVAL
207  
208 # add == Spritz::HASH::add (inherit)
209 # finish == Spritz::HASH::finish (inherit)
210  
211 MODULE = Crypt::Spritz PACKAGE = Crypt::Spritz::AEAD PREFIX = spritz_aead_
212  
213 # new == Spritz::MAC::new (inherit)
214 # nonce == absorb_and_stop (alias)
215 # associated_data == absorb_and_stop (alias)
216 # encrypt == Spritz::Cipher::crypt (xs-alias)
217 # decrypt == Spritz::Cipher::crypt (xs-alias)
218 # finish == Spritz::MAC::finish (alias)
219  
220 MODULE = Crypt::Spritz PACKAGE = Crypt::Spritz::AEAD::XOR PREFIX = spritz_aead_xor_
221  
222 # new == Spritz::MAC::new (inherit)
223 # nonce == Spritz::AEAD::nonce (inherit)
224 # associated_data == Spritz::AEAD::associated_data (inherit)
225 # crypt == Spritz::Cipher::crypt (xs-alias)
226 # finish == Spritz::AEAD::finish (inherit)
227  
228 void
229 crypt_inplace (Crypt::Spritz self, SV *I)
230 CODE:
231 0 sv_force_normal (I);
232 {
233 0 STRLEN len; char *ptr = SvPVbyte (I, len);
234 0 ▶ if (len > 400) perlinterp_release ();
Branch: 1 branch
BranchTrueFalseTotal
if (len > 400) perlinterp_release (); 0 0 0
235 0 spritz_aead_xor_crypt (self, ptr, ptr, len);
236 0 ▶ if (len > 400) perlinterp_acquire ();
Branch: 1 branch
BranchTrueFalseTotal
if (len > 400) perlinterp_acquire (); 0 0 0
237 }
238  
239 MODULE = Crypt::Spritz PACKAGE = Crypt::Spritz::PRNG PREFIX = spritz_prng_
240  
241 SV *
242 new (SV *klass, SV *S = 0)
243 CODE:
244 {
245 18 ▶ STRLEN len = 0; char *ptr = S ? SvPVbyte (S, len) : 0;
Branch: 1 branch
BranchTrueFalseTotal
STRLEN len = 0; char *ptr = S ? SvPVbyte (S, len) : 0; 9 0 9
246 9 RETVAL = alloc_state (klass);
247 9 spritz_prng_init ((spritz_state *)SvPVX (SvRV (RETVAL)), ptr, len);
248 }
249 OUTPUT:
250 RETVAL
251  
252 # add == absorb (alias)
253 # get == squeeze (alias)
254  
« spritz/spritz.h ↑ Summary spritz/spritz.c »