1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
/* $Header: usersub.c,v 4.0 91/03/20 01:55:56 lwall Locked $
*
* This file contains stubs for routines that the user may define to
* set up glue routines for C libraries or to decrypt encrypted scripts
* for execution.
*
* $Log: usersub.c,v $
* Revision 4.0 91/03/20 01:55:56 lwall
* 4.0 baseline.
*
*/
#include "EXTERN.h"
#include "perl.h"
userinit()
{
return 0;
}
/*
* The following is supplied by John MacDonald as a means of decrypting
* and executing (presumably proprietary) scripts that have been encrypted
* by a (presumably secret) method. The idea is that you supply your own
* routine in place of cryptfilter (which is purposefully a very weak
* encryption). If an encrypted script is detected, a process is forked
* off to run the cryptfilter routine as input to perl.
*/
#ifdef CRYPTSCRIPT
#include <signal.h>
#ifdef I_VFORK
#include <vfork.h>
#endif
#define CRYPT_MAGIC_1 0xfb
#define CRYPT_MAGIC_2 0xf1
cryptfilter( fil )
FILE * fil;
{
int ch;
while( (ch = getc( fil )) != EOF ) {
putchar( (ch ^ 0x80) );
}
}
#ifndef MSDOS
static FILE *lastpipefile;
static int pipepid;
#ifdef VOIDSIG
# define VOID void
#else
# define VOID int
#endif
FILE *
mypfiopen(fil,func) /* open a pipe to function call for input */
FILE *fil;
VOID (*func)();
{
int p[2];
STR *str;
if (pipe(p) < 0) {
fclose( fil );
fatal("Can't get pipe for decrypt");
}
/* make sure that the child doesn't get anything extra */
fflush(stdout);
fflush(stderr);
while ((pipepid = fork()) < 0) {
if (errno != EAGAIN) {
close(p[0]);
close(p[1]);
fclose( fil );
fatal("Can't fork for decrypt");
}
sleep(5);
}
if (pipepid == 0) {
close(p[0]);
if (p[1] != 1) {
dup2(p[1], 1);
close(p[1]);
}
(*func)(fil);
fflush(stdout);
fflush(stderr);
_exit(0);
}
close(p[1]);
fclose(fil);
str = afetch(fdpid,p[0],TRUE);
str->str_u.str_useful = pipepid;
return fdopen(p[0], "r");
}
cryptswitch()
{
int ch;
#ifdef STDSTDIO
/* cheat on stdio if possible */
if (rsfp->_cnt > 0 && (*rsfp->_ptr & 0xff) != CRYPT_MAGIC_1)
return;
#endif
ch = getc(rsfp);
if (ch == CRYPT_MAGIC_1) {
if (getc(rsfp) == CRYPT_MAGIC_2) {
rsfp = mypfiopen( rsfp, cryptfilter );
preprocess = 1; /* force call to pclose when done */
}
else
fatal( "bad encryption format" );
}
else
ungetc(ch,rsfp);
}
FILE *
cryptopen(cmd) /* open a (possibly encrypted) program for input */
char *cmd;
{
FILE *fil = fopen( cmd, "r" );
lastpipefile = Nullfp;
pipepid = 0;
if( fil ) {
int ch = getc( fil );
int lines = 0;
int chars = 0;
/* Search for the magic cookie that starts the encrypted script,
** while still allowing a few lines of unencrypted text to let
** '#!' and the nih hack both continue to work. (These lines
** will end up being ignored.)
*/
while( ch != CRYPT_MAGIC_1 && ch != EOF && lines < 5 && chars < 300 ) {
if( ch == '\n' )
++lines;
ch = getc( fil );
++chars;
}
if( ch == CRYPT_MAGIC_1 ) {
if( (ch = getc( fil ) ) == CRYPT_MAGIC_2 ) {
if( perldb ) fatal("can't debug an encrypted script");
/* we found it, decrypt the rest of the file */
fil = mypfiopen( fil, cryptfilter );
return( lastpipefile = fil );
} else
/* if its got MAGIC 1 without MAGIC 2, too bad */
fatal( "bad encryption format" );
}
/* this file is not encrypted - rewind and process it normally */
rewind( fil );
}
return( fil );
}
VOID
cryptclose(fil)
FILE *fil;
{
if( fil == Nullfp )
return;
if( fil == lastpipefile )
mypclose( fil );
else
fclose( fil );
}
#endif /* !MSDOS */
#endif /* CRYPTSCRIPT */
|
