| 2 |
- |
1 |
cipher3des.c:18: uchar key[3][8];
|
|
|
2 |
cipher3des.c:44: "3des-cbc",
|
|
|
3 |
cipher3des.c:45: 8,
|
|
|
4 |
cipheraes.c:24: setupAESstate(&cs->state, c->s2cek, bits/8, c->s2civ);
|
|
|
5 |
cipheraes.c:26: setupAESstate(&cs->state, c->c2sek, bits/8, c->c2siv);
|
|
|
6 |
cipheraes.c:34: return initaes(c, dir, 128);
|
|
|
7 |
cipheraes.c:40: return initaes(c, dir, 192);
|
|
|
8 |
cipheraes.c:46: return initaes(c, dir, 256);
|
|
|
9 |
cipherblowfish.c:22: for(i = 0; i < 16; ++i)
|
|
|
10 |
cipherblowfish.c:25: for(i = 0; i < 16; ++i)
|
|
|
11 |
cipherblowfish.c:28: for(i = 0; i < 8; ++i)
|
|
|
12 |
cipherblowfish.c:31: for(i = 0; i < 8; ++i)
|
|
|
13 |
cipherblowfish.c:39: setupBFstate(&cs->state, c->s2cek, 16, c->s2civ);
|
|
|
14 |
cipherblowfish.c:41: setupBFstate(&cs->state, c->c2sek, 16, c->c2siv);
|
|
|
15 |
cipherblowfish.c:62: 8,
|
|
|
16 |
cipherrc4.c:21: setupRC4state(&cs->state, c->s2cek, 16);
|
|
|
17 |
cipherrc4.c:23: setupRC4state(&cs->state, c->c2sek, 16);
|
|
|
18 |
cipherrc4.c:41: 8,
|
|
|
19 |
dh.c:16: Errnokey = -2, /* no key on keyring */
|
|
|
20 |
dh.c:30: "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
|
|
|
21 |
dh.c:37: * 2048-bit MODP group (id 14) from RFC 3526
|
|
|
22 |
dh.c:41: "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
|
|
|
23 |
dh.c:46: "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
|
|
|
24 |
dh.c:47: "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
|
|
|
25 |
dh.c:50: "15728E5A8AACAA68FFFFFFFFFFFFFFFF";
|
|
|
26 |
dh.c:69: two = strtomp("2", nil, 10, nil);
|
|
|
27 |
dh.c:70: p1 = strtomp(group1p, nil, 16, nil);
|
|
|
28 |
dh.c:71: p14 = strtomp(group14p, nil, 16, nil);
|
|
|
29 |
dh.c:112: myrsakey.pub.n = strtomp(p+3, nil, 16, nil);
|
|
|
30 |
dh.c:123: myrsakey.pub.ek = strtomp(p+4, nil, 16, nil);
|
|
|
31 |
dh.c:136: myrsakey.dk = strtomp(p+5, nil, 16, nil);
|
|
|
32 |
dh.c:179: mydsskey.pub.p = strtomp(p+3, nil, 16, nil);
|
|
|
33 |
dh.c:186: mydsskey.pub.q = strtomp(p+3, nil, 16, nil);
|
|
|
34 |
dh.c:193: mydsskey.pub.alpha = strtomp(p+7, nil, 16, nil);
|
|
|
35 |
dh.c:200: mydsskey.pub.key = strtomp(p+5, nil, 16, nil);
|
|
|
36 |
dh.c:211: mydsskey.secret = strtomp(p+9, nil, 16, nil);
|
|
|
37 |
dh.c:242: n = nb - (nelem(sha1der) + SHA1dlen) - 3;
|
|
|
38 |
dh.c:266: n = (nbit + 7) / 8;
|
|
|
39 |
dh.c:269: /* Compute s: RFC 3447 */
|
|
|
40 |
dh.c:285: auth_rpc(ar, "start", "role=sign proto=rsa", 19) != ARok ||
|
|
|
41 |
dh.c:328: n = (nbit + 7) / 8;
|
|
|
42 |
dh.c:330: /* Compute s: RFC 3447 */
|
|
|
43 |
dh.c:333: s = mpnew(1024);
|
|
|
44 |
dh.c:350: buf = emalloc9p(Blobsz / 2);
|
|
|
45 |
dh.c:352: p = (char *)get_string(nil, (uchar *)sig, buf, Blobsz / 2, nil);
|
|
|
46 |
dh.c:406: uchar sstr[2*SHA1dlen];
|
|
|
47 |
dh.c:424: auth_rpc(ar, "start", "role=sign proto=dsa", 19) != ARok ||
|
|
|
48 |
dh.c:436: add_block(sig, sstr, 2*SHA1dlen);
|
|
|
49 |
dh.c:451: return dh_server(c, pack1, p1, 1024);
|
|
|
50 |
dh.c:457: return dh_server(c, pack1, p14, 2048);
|
|
|
51 |
dh.c:474: y = mprand(nbit / 8, genrandom, nil);
|
|
|
52 |
dh.c:491: /* Compute H: RFC 4253 */
|
|
|
53 |
dh.c:570: c->e = mpnew(1024);
|
|
|
54 |
dh.c:575: c->x = mprand(128, genrandom, nil);
|
|
|
55 |
dh.c:597: keymbox.msg = smprint("b%04ld%s", strlen(newkey), newkey);
|
|
|
56 |
dh.c:606: keymbox.msg = smprint("%c%04ld%s", n == NoKeyFile || n == NoKey?
|
|
|
57 |
dh.c:616: keymbox.msg = smprint("f%04ld%s", strlen(newkey), newkey);
|
|
|
58 |
dh.c:690: char buf[10];
|
|
|
59 |
dh.c:704: q += nhgetl(q) + 4;
|
|
|
60 |
dh.c:707: k = mpnew(1024);
|
|
|
61 |
dh.c:710: /* Compute H: RFC 4253 */
|
|
|
62 |
dh.c:741: q += nhgetl(q) + 4;
|
|
|
63 |
dh.c:760: keymbox.msg = smprint("f%04ld%s", strlen(newkey), newkey);
|
|
|
64 |
dh.c:764: keymbox.msg = smprint("f%04ld%s", strlen(newkey), newkey);
|
|
|
65 |
dh.c:796: e = mpnew(2048);
|
|
|
66 |
dh.c:797: x = mprand(256, genrandom, nil);
|
|
|
67 |
dh.c:828: char buf[82], *bp, *be; /* magic 82 */
|
|
|
68 |
dh.c:832: /* Compute 40 bytes (320 bits) of keys: each alg can use what it needs */
|
|
|
69 |
dh.c:900: for (n = 0, bp = buf; n < SHA1dlen*2; ++n)
|
|
|
70 |
dh.c:905: for (n = 0, bp = buf; n < SHA1dlen*2; ++n)
|
|
|
71 |
dh.c:910: for (n = 0, bp = buf; n < SHA1dlen*2; ++n)
|
|
|
72 |
dh.c:915: for (n = 0, bp = buf; n < SHA1dlen*2; ++n)
|
|
|
73 |
dial.c:14: Maxstring = 128,
|
|
|
74 |
dial.c:15: Maxpath = 256,
|
|
|
75 |
dial.c:17: Maxcsreply = 64*80, /* this is probably overly generous */
|
|
|
76 |
dial.c:22: Maxconnms = 2*60*1000, /* 2 minutes */
|
|
|
77 |
dial.c:171: char *fields[5]; /* pid + 3 times + error */
|
|
|
78 |
dial.c:177: if (n < 4)
|
|
|
79 |
dial.c:188: strncpy(conn->err, fields[4], sizeof conn->err - 1);
|
|
|
80 |
dial.c:210: char exitsts[2*ERRMAX];
|
|
|
81 |
dial.c:385: bleft = sizeof dp->addrlist - 2; /* 2 is room for \n\0 */
|
|
|
82 |
dial.thread.c:22: Defstksize = 8192,
|
|
|
83 |
dial.thread.c:24: Maxstring = 128,
|
|
|
84 |
dial.thread.c:25: Maxpath = 256,
|
|
|
85 |
dial.thread.c:27: Maxcsreply = 64*80, /* this is probably overly generous */
|
|
|
86 |
dial.thread.c:32: Maxconnms = 2*60*1000, /* 2 minutes */
|
|
|
87 |
dial.thread.c:57: int kidthrids[64]; /* one per addr; ought to be enough */
|
|
|
88 |
dial.thread.c:393: bleft = sizeof dp->addrlist - 2; /* 2 is room for \n\0 */
|
|
|
89 |
netssh.c:48: PKA *pkas[3];
|
|
|
90 |
netssh.c:71: char uid[32];
|
|
|
91 |
netssh.c:175: case '9':
|
|
|
92 |
netssh.c:209: keymbox.mchan = chancreate(4, 0);
|
|
|
93 |
netssh.c:259: werrstr("bad length in 9P2000 message header");
|
|
|
94 |
netssh.c:283: netsshsrv.tree = alloctree(uid, uid, 0777, nil);
|
|
|
95 |
netssh.c:284: rootfile = createfile(netsshsrv.tree->root, "ssh", uid, 0555|DMDIR,
|
|
|
96 |
netssh.c:286: clonefile = createfile(rootfile, "clone", uid, 0666, (void*)Qclone);
|
|
|
97 |
netssh.c:287: ctlfile = createfile(rootfile, "ctl", uid, 0666, (void*)Qctl);
|
|
|
98 |
netssh.c:288: keysfile = createfile(rootfile, "keys", uid, 0600, (void *)Qreqrem);
|
|
|
99 |
netssh.c:305: d.mode = 0666;
|
|
|
100 |
netssh.c:330: char buf[32];
|
|
|
101 |
netssh.c:347: /* should use dial(2) instead of diddling /net/tcp */
|
|
|
102 |
netssh.c:455: /* should use dial(2) instead of diddling /net/tcp */
|
|
|
103 |
netssh.c:541: hnputl(p2->payload + 5, c->chans[i]->id);
|
|
|
104 |
netssh.c:542: hnputl(p2->payload + 9, Maxpayload);
|
|
|
105 |
netssh.c:543: hnputl(p2->payload + 13, Maxrpcbuf);
|
|
|
106 |
netssh.c:544: p2->rlength = 18;
|
|
|
107 |
netssh.c:591: if (sc->rwindow < 16*1024) { /* magic. half-way, maybe? */
|
|
|
108 |
netssh.c:598: hnputl(p->payload+5, Maxpayload);
|
|
|
109 |
netssh.c:599: p->rlength += 8;
|
|
|
110 |
netssh.c:691: n = pread(c->ctlfd, buf, 10, 0); // magic 10
|
|
|
111 |
netssh.c:725: n = pread(c->ctlfd, buf, 10, 0); /* magic 10 */
|
|
|
112 |
netssh.c:813: n = ioread(io, c->ctlfd, buf, 10); /* magic 10 */
|
|
|
113 |
netssh.c:989: * should use dial(2) instead of doing it by hand.
|
|
|
114 |
netssh.c:991: sshdebug(c, "tcp connect %s %s", toks[1], ntok > 3? toks[2]: "");
|
|
|
115 |
netssh.c:992: return fprint(c->ctlfd, "connect %s %s", toks[1], ntok > 3? toks[2]: "");
|
|
|
116 |
netssh.c:999: char *attrs[5];
|
|
|
117 |
netssh.c:1002: if (ntok < 3 || ntok > 4)
|
|
|
118 |
netssh.c:1008: c->user = estrdup9p(toks[2]);
|
|
|
119 |
netssh.c:1011: if (ntok == 4 && strcmp(toks[1], "k") == 0) {
|
|
|
120 |
netssh.c:1018: c->password = estrdup9p(toks[3]);
|
|
|
121 |
netssh.c:1028: attrs[2] = smprint("user=%s", c->user);
|
|
|
122 |
netssh.c:1029: attrs[3] = smprint("sys=%s", c->remote);
|
|
|
123 |
netssh.c:1033: if (ntok == 3)
|
|
|
124 |
netssh.c:1034: c->authkey = factlookup(4, 2, attrs);
|
|
|
125 |
netssh.c:1036: attrs[4] = toks[3];
|
|
|
126 |
netssh.c:1037: c->authkey = factlookup(5, 2, attrs);
|
|
|
127 |
netssh.c:1039: free(attrs[2]);
|
|
|
128 |
netssh.c:1040: free(attrs[3]);
|
|
|
129 |
netssh.c:1080: char *tcpconn2, *buf, *toks[4];
|
|
|
130 |
netssh.c:1111: if (ntok < 2)
|
|
|
131 |
netssh.c:1118: if (ntok < 2)
|
|
|
132 |
netssh.c:1121: * should use dial(2) instead of doing it by hand.
|
|
|
133 |
netssh.c:1131: pkas[2] = nil;
|
|
|
134 |
netssh.c:1161: /* should use dial(2) instead of diddling /net/tcp */
|
|
|
135 |
netssh.c:1187: add_string(p, toks[2]);
|
|
|
136 |
netssh.c:1194: fprint(c->ctlfd, "reject %s %s", buf, toks[2]);
|
|
|
137 |
netssh.c:1271: char *cmd, *q, *buf, *toks[4];
|
|
|
138 |
netssh.c:1286: if (r->ifcall.count <= 10)
|
|
|
139 |
netssh.c:1287: buf = emalloc9p(10 + 1);
|
|
|
140 |
netssh.c:1357: for (n = 2; n < ntok; ++n) {
|
|
|
141 |
netssh.c:1396: p->rlength += 4;
|
|
|
142 |
netssh.c:1413: * called clunk. But if there are no other references, a 9P Tclunk
|
|
|
143 |
netssh.c:1485: p->rlength += 4;
|
|
|
144 |
netssh.c:1603: c->dir = createfile(rootfile, buf, uid, 0555|DMDIR,
|
|
|
145 |
netssh.c:1605: c->clonefile = createfile(c->dir, "clone", uid, 0666,
|
|
|
146 |
netssh.c:1607: c->ctlfile = createfile(c->dir, "ctl", uid, 0666,
|
|
|
147 |
netssh.c:1609: c->datafile = createfile(c->dir, "data", uid, 0666,
|
|
|
148 |
netssh.c:1611: c->listenfile = createfile(c->dir, "listen", uid, 0666,
|
|
|
149 |
netssh.c:1613: c->localfile = createfile(c->dir, "local", uid, 0444,
|
|
|
150 |
netssh.c:1615: c->remotefile = createfile(c->dir, "remote", uid, 0444,
|
|
|
151 |
netssh.c:1617: c->statusfile = createfile(c->dir, "status", uid, 0444,
|
|
|
152 |
netssh.c:1619: c->tcpfile = createfile(c->dir, "tcp", uid, 0444,
|
|
|
153 |
netssh.c:1661: sc->dir = createfile(c->dir, buf, uid, 0555|DMDIR,
|
|
|
154 |
netssh.c:1663: sc->ctl = createfile(sc->dir, "ctl", uid, 0666,
|
|
|
155 |
netssh.c:1665: sc->data = createfile(sc->dir, "data", uid, 0666,
|
|
|
156 |
netssh.c:1667: sc->listen = createfile(sc->dir, "listen", uid, 0666,
|
|
|
157 |
netssh.c:1669: sc->request = createfile(sc->dir, "request", uid, 0666,
|
|
|
158 |
netssh.c:1671: sc->status = createfile(sc->dir, "status", uid, 0444,
|
|
|
159 |
netssh.c:1673: sc->tcp = createfile(sc->dir, "tcp", uid, 0444,
|
|
|
160 |
netssh.c:1688: sc->inchan = chancreate(4, 0);
|
|
|
161 |
netssh.c:1692: sc->reqchan = chancreate(4, 0);
|
|
|
162 |
netssh.c:1792: if (n < 5) /* can't be a valid SSH id string */
|
|
|
163 |
netssh.c:1799: if (n < 5) /* can't be a valid SSH id string */
|
|
|
164 |
netssh.c:1855: 0 && c->role == Client && strncmp(remid, "SSH-2", 5) != 0 &&
|
|
|
165 |
netssh.c:1856: strncmp(remid, "SSH-1.99", 8) != 0) {
|
|
|
166 |
netssh.c:1953: if (n < 5) { /* can't be a valid SSH id string */
|
|
|
167 |
netssh.c:1961: strncmp(path, "SSH-2", 5) != 0 &&
|
|
|
168 |
netssh.c:1962: strncmp(path, "SSH-1.99", 8) != 0) {
|
|
|
169 |
netssh.c:1999: /* should use hangup in dial(2) instead of diddling /net/tcp */
|
|
|
170 |
netssh.c:2002: iowrite(io, fd, "hangup", 6);
|
|
|
171 |
netssh.c:2024: for (i = 0; i < 16; ++i)
|
|
|
172 |
netssh.c:2027: add_packet(c->skexinit, buf, 16); /* cookie */
|
|
|
173 |
netssh.c:2063: memset(buf, 0, 5);
|
|
|
174 |
netssh.c:2064: add_packet(c->skexinit, buf, 5);
|
|
|
175 |
netssh.c:2094: get_string(p, p->payload + 5, buf, Arbbufsz, nil);
|
|
|
176 |
netssh.c:2104: memmove(c->c2siv, c->nc2siv, SHA1dlen*2);
|
|
|
177 |
netssh.c:2105: memmove(c->s2civ, c->ns2civ, SHA1dlen*2);
|
|
|
178 |
netssh.c:2106: memmove(c->c2sek, c->nc2sek, SHA1dlen*2);
|
|
|
179 |
netssh.c:2107: memmove(c->s2cek, c->ns2cek, SHA1dlen*2);
|
|
|
180 |
netssh.c:2108: memmove(c->c2sik, c->nc2sik, SHA1dlen*2);
|
|
|
181 |
netssh.c:2109: memmove(c->s2cik, c->ns2cik, SHA1dlen*2);
|
|
|
182 |
netssh.c:2231: add_block(p2, p->payload + 5, 4);
|
|
|
183 |
netssh.c:2232: hnputl(p2->payload + p2->rlength - 1, 4);
|
|
|
184 |
netssh.c:2233: p2->rlength += 4;
|
|
|
185 |
netssh.c:2256: get_string(p, p->payload + 5, buf, Arbbufsz, nil);
|
|
|
186 |
netssh.c:2265: get_string(p, p->payload + 2, buf, Arbbufsz, nil);
|
|
|
187 |
netssh.c:2299: ch->twindow = nhgetl(q+4);
|
|
|
188 |
netssh.c:2325: ch->otherid = nhgetl(p->payload+5);
|
|
|
189 |
netssh.c:2326: ch->twindow = nhgetl(p->payload+9);
|
|
|
190 |
netssh.c:2340: ch->twindow += nhgetl(p->payload + 5);
|
|
|
191 |
netssh.c:2354: pl->rem = nhgetl(p->payload + 5);
|
|
|
192 |
netssh.c:2355: pl->st = pl->pack->payload + 9;
|
|
|
193 |
netssh.c:2357: pl->rem = nhgetl(p->payload + 9);
|
|
|
194 |
netssh.c:2358: pl->st = pl->pack->payload + 13;
|
|
|
195 |
netssh.c:2386: p2->rlength += 4;
|
|
|
196 |
netssh.c:2411: q = get_string(p, p->payload+5, buf, Arbbufsz, nil);
|
|
|
197 |
netssh.c:2418: memmove(pl->pack->payload + n, q + 1, p->rlength - (11 + n-2));
|
|
|
198 |
netssh.c:2419: pl->rem = p->rlength - 11 + 2;
|
|
|
199 |
netssh.c:2458: nb = 4;
|
|
|
200 |
netssh.c:2477: np = ioreadn(c->rio, c->datafd, p->nlength + nb, p->rlength + 4 - nb);
|
|
|
201 |
netssh.c:2479: nm = ioreadn(c->rio, c->datafd, p->nlength + p->rlength + 4,
|
|
|
202 |
netssh.c:2480: SHA1dlen); /* SHA1dlen was magic 20 */
|
|
|
203 |
netssh.c:2494: /* SHA1dlen was magic 20 */
|
|
|
204 |
netssh.c:2495: if (np != p->rlength + 4 - nb || c->inmac != -1 && nm != SHA1dlen) {
|
|
|
205 |
netssh.c:2500: p->rlength = n - 4;
|
|
|
206 |
netssh.c:2531: get_string(p, p->payload + 5, buf, Arbbufsz, nil);
|
|
|
207 |
netssh.c:2543: case -2: /* can't happen, now at least */
|
|
|
208 |
netssh.c:2603: q = p->payload + 17;
|
|
|
209 |
netssh.c:2702: q = p->payload + 17;
|
|
|
210 |
netssh.c:2802: cap = emalloc9p(fromtosz + sizeof(rand)*3 + 1);
|
|
|
211 |
netssh.c:2803: snprint(cap, fromtosz + sizeof(rand)*3 + 1, "%s@%s", from, to);
|
|
|
212 |
netssh.c:2806: enc64(key, sizeof(rand)*3, rand, sizeof(rand));
|
|
|
213 |
netssh.c:2849: werrstr("Password mismatch 2");
|
|
|
214 |
netssh.c:2875: char method[32];
|
|
|
215 |
netssh.c:2938: char key1[DESKEYLEN], key2[DESKEYLEN], method[32];
|
|
|
216 |
netssh.c:3042: ek = strtomp(r+4, nil, 16, nil);
|
|
|
217 |
netssh.c:3043: nk = strtomp(s+3, nil, 16, nil);
|
|
|
218 |
netssh.c:3134: if (c->clonefile->ref <= 2 && c->ctlfile->ref <= 2 &&
|
|
|
219 |
netssh.c:3135: c->datafile->ref <= 2 && c->listenfile->ref <= 2 &&
|
|
|
220 |
netssh.c:3136: c->localfile->ref <= 2 && c->remotefile->ref <= 2 &&
|
|
|
221 |
netssh.c:3137: c->statusfile->ref <= 2)
|
|
|
222 |
pubkey.c:12: Arbsz = 256,
|
|
|
223 |
pubkey.c:22: n = strtoul(s, &p, 10);
|
|
|
224 |
pubkey.c:33: n = strtoul(s, &p, 10);
|
|
|
225 |
pubkey.c:79: if(parsepubkey(s, key, sp, 10) == 0 ||
|
|
|
226 |
pubkey.c:80: parsepubkey(s, key, sp, 16) == 0)
|
|
|
227 |
pubkey.c:164: Bprint(bw, "%s %d %.10M %.10M\n",
|
|
|
228 |
pubkey.c:169: Bprint(bw, "%s %d %.10M %.10M\n", host, mpsignif(hostkey->n),
|
|
|
229 |
pubkey.c:213: fd = create(keyfile, OWRITE, 0666);
|
|
|
230 |
pubkey.c:220: if(seek(fd, 0, 2) >= 0 &&
|
|
|
231 |
pubkey.c:221: fprint(fd, "%s %d %.10M %.10M\n", host, mpsignif(key->n),
|
|
|
232 |
rsa2ssh2.c:54: e = strtomp(ep+4, nil, 16, nil);
|
|
|
233 |
rsa2ssh2.c:55: n = strtomp(np+3, nil, 16, nil);
|
|
|
234 |
rsa2ssh2.c:61: sysfatal("base-64 encoding failed\n");
|
|
|
235 |
ssh.c:130: oalarm = alarm(5*1000); /* don't get stuck here */
|
|
|
236 |
ssh.c:163: // for (fd = 3; fd < 40; fd++)
|
|
|
237 |
ssh.c:219: if (buf[n-1] == ('u' & 037))
|
|
|
238 |
ssh.c:251: write(kconsfd, buf+5, n);
|
|
|
239 |
ssh.c:257: write(kconsfd, buf+5, n);
|
|
|
240 |
ssh.c:265: seek(keyfd, 0, 2);
|
|
|
241 |
ssh.c:266: if (readn(keyfd, buf, 5) <= 0)
|
|
|
242 |
ssh.c:268: buf[5] = 0;
|
|
|
243 |
ssh.c:269: n = strtol(buf+1, nil, 10);
|
|
|
244 |
ssh.c:270: n = readn(keyfd, buf+5, n);
|
|
|
245 |
ssh.c:273: buf[n+5] = 0;
|
|
|
246 |
ssh.c:278: fprint(kconsfd, "%s\n", buf+5);
|
|
|
247 |
ssh.c:292: if (size < 6)
|
|
|
248 |
ssh.c:306: n = read(keyfd, buf, 5); /* reading /net/ssh/keys */
|
|
|
249 |
ssh.c:309: buf[5] = 0;
|
|
|
250 |
ssh.c:310: n = strtol(buf+1, nil, 10);
|
|
|
251 |
ssh.c:311: n = readn(keyfd, buf+5, n);
|
|
|
252 |
ssh.c:312: buf[n < 0? 5: n+5] = 0;
|
|
|
253 |
ssh.c:318: fprint(kconsfd, "%s\n", buf+5);
|
|
|
254 |
ssh.c:404: ds = netmkaddr(remote, dir, "22"); /* tcp port 22 is ssh */
|
|
|
255 |
ssh.c:578: char buf[64];
|
|
|
256 |
ssh.c:582: return strlen(buf) >= 9 && strcmp(buf+strlen(buf)-9, "/dev/cons") == 0;
|
|
|
257 |
sshsession.c:228: errfd = 2;
|
|
|
258 |
sshsession.c:411: q += 4;
|
|
|
259 |
sshsession.c:425: q += 4;
|
|
|
260 |
sshsession.c:475: dup(datafd, 2);
|
|
|
261 |
transport.c:42: p->rlength += 4;
|
|
|
262 |
transport.c:50: *data += 4;
|
|
|
263 |
transport.c:68: p->rlength += 4;
|
|
|
264 |
transport.c:77: uchar nn[4];
|
|
|
265 |
transport.c:82: memmove(q, nn, 4);
|
|
|
266 |
transport.c:83: memmove(q+4, s, n);
|
|
|
267 |
transport.c:84: p->rlength += n + 4;
|
|
|
268 |
transport.c:95: q += 4;
|
|
|
269 |
transport.c:115: n = mptobe(x, q + 4, Maxpktpay - p->rlength + 1 - 4, nil);
|
|
|
270 |
transport.c:116: if(q[4] & 0x80){
|
|
|
271 |
transport.c:117: memmove(q + 5, q + 4, n);
|
|
|
272 |
transport.c:118: q[4] = 0;
|
|
|
273 |
transport.c:122: p->rlength += n + 4;
|
|
|
274 |
transport.c:128: return betomp(q + 4, nhgetl(q), nil);
|
|
|
275 |
transport.c:139: blklen = 8;
|
|
|
276 |
transport.c:145: if(blklen < 8)
|
|
|
277 |
transport.c:146: blklen = 8;
|
|
|
278 |
transport.c:149: n2 = blklen - (n1 + 5) % blklen;
|
|
|
279 |
transport.c:150: if(n2 < 4)
|
|
|
280 |
transport.c:162: memmove(buf + 4, p->nlength, p->rlength + 4);
|
|
|
281 |
transport.c:163: hmac_sha1(buf, p->rlength + 8, c->outik, maclen, q, nil);
|
|
|
282 |
transport.c:167: cryptos[c->encrypt]->encrypt(c->enccs, p->nlength, p->rlength + 4);
|
|
|
283 |
transport.c:173: return p->rlength + 4 + maclen;
|
|
|
284 |
transport.c:189: nb = 4;
|
|
|
285 |
transport.c:193: p->rlength -= SHA1dlen; /* was magic 20 */
|
|
|
286 |
transport.c:197: p->rlength + 4 - nb);
|
|
|
287 |
transport.c:201: memmove(buf + 4, p->nlength, nlength + 4);
|
|
|
288 |
transport.c:202: hmac_sha1(buf, nlength + 8, c->inik, SHA1dlen, rmac, nil);
|
|
|
289 |
transport.c:227: if(i % 16 == 15)
|
|
|
290 |
transport.c:229: if(q - buf > Copybufsz - 4){
|