Free to embed software for linux

Download Embedded extension downloads all or selected embedded objects on a webpage. Can be used for downloading movies, mp3s, flash, quicktime, or other embedded files.

When the Download Embedded plugin detects an embedded object, a small red arrow will appear on the status bar at the bottom of your firefox window. Just click that and either download them all or pick which ones you want to download. Enjoy!

If you were using the old download embedded (0.1), -=please=- remove it before installing this one.

EmbedCover is a script for embedding album cover images in MP3 files. EmbedCover script will automatically look up the image associated to it in amaroK and embed this image in the file.

The MP3 file must have an ID3-V2 tag, otherwise the script will abort, and the file must be in your Collection.

It is recommended that you back up your MP3 file before using this script on it.

Although the script is designed not to harm your file, the operation is not reversible and should therefore be used with caution.

Future versions will also be able to remove embedded cover images from a file.

Python in Scheme is a scheme library that allows you to run Python code within Scheme.

Python in Scheme project uses the Python/C API to embed a Python interpreter.

HTML::Embperl is a Perl module for building dynamic Websites with Perl.

SYNOPSIS

Embperl is a Perl extension module which gives you the power to embed Perl code directly in your HTML documents (like server-side includes for shell commands).

If building more than a single page, you may also want to take a look at "perldoc EmbperlObject" which lets you build your website out of small reusable objects.

Additionally, "perldoc HTML::Embperl::Mail" allows you to send the resulting page via email.

SQL::Statement::Embed can embed a SQL engine in a DBD or module.

SQL::Statement is designed to be easy to embed in other modules and to be especially easy to embed in DBI drivers. It provides a SQL Engine and the other module needs to then provide a data source and a storage mechanism. For example, the DBD::CSV module uses SQL::Statement as an embedded SQL engine by implementing a file-based data source and by using DBI as the user interface. Similarly DBD::Amazon uses SQL::Statement as its SQL engine, provides its own extensions to the supported SQL syntax, and uses on-the-fly searches of Amazon.com as its data source.

SQL::Statement is the basis for eight existing DBDs (DBI database drivers). If you have a new data source, you too can create a DBD without having to reinvent the SQL wheel. Its fun, its easy, become a DBD author today!

SQL::Statement can be also be embedded without DBI. Well explore that first since developing a DBD uses most of the same methods and techniques.

The role of SQL::Statement subclasses

SQL::Statement provides a SQL parsing and execution engine. It does not provide a data source or storage mechanism other than in-memory tables. The DBD::File module is a subclass of SQL::Statement that provides access to file-based storage mechanisms. Its quite possible to use things other than files as data souces, in which case we wouldnt use DBD::File, instead wed replace DBD::Files methods with our own. In the examples below, well use DBD::File, replacing only a few methods.

SQL::Statement provides SQL parsing and evaluation and DBD::File provides file-based storage. The only thing missing is a data source - what we actually want to store and query. As an example suppose we are going to create a subclass called Foo that will provide as a data source a simple file similar to a passwd file - one record per line, fields separated by colons, with only three fields "username, uid, gid".

Consider what needs to happen to perform a SELECT query on our Foo data:

* recieve a SQL string
* parse the SQL string into a request structure
* open the table(s) specified in the request
* define column names and postions for the table
* read rows from the table
* convert the rows from colon-separated format into perl arrays
* match the columns and rows against the requested selection criteria
* return requested rows and columns to the user

To perform operations like INSERT and DELETE, we also need to:

* convert rows from perl arrays into colon-separated format
* write rows
* delete rows

SQL::Statement takes care of all of the SQL parsing and evaluation. DBD::File takes care of file opening, reading, writing, and deleting. So the only things Foo is really responsible for are:

* define column names and postions for the table
* convert rows from colon-separated format into perl arrays
* convert rows from perl arrays into colon-separated format

In SQL::Statement subclasses these responsibilities are assigned to two objects, a ::Statement object is responsible for opening the table, defining the column names and positions, and for creating new ::Table objects. A ::Table object is responsible for reading, converting, writing, and deleting data.

Stego is a simple encryption and decryption program that hides data inside BMP files. It allows you to store messages in picture files and send them to others.

The recipient can decode the image by reading the image using this program.

You get 3 components with this software:

1. stego: the GUI version of image encryption, ecrption
2. encrypt: commmand line tool to embed text into images,
3. decrypt: command line toll to extract the text from images.

Installation:

./autogen.sh
./configure --prefix=/tmp
make
make install
$/tmp/bin/stego & #yove done it

twocrypt provides a crypto tool with a deniable encryption option.
twocrypt (2c) is a tool for the ultra-paranoid, providing a traditional crypto, but also an option of deniable (subpoena-proof) encryption. It encrypts one or two files at once.
Each file can be recovered with its respective passphrase, but the presence of more than one file cannot be demonstrated, and the presence of this option alone should not be a credible argument for data hiding.
2c2 is a simple symmetric file encryption utility. It comes with an
interesting optional feature - it is capable to embed an additional file
within an encrypted data. This is done in a way that cannot be detected
without knowing the passphrase protecting the "hidden" file, even if the
password for the primary file is disclosed. The design is such that the
fact of using this method alone does not constitute a credible evidence of
data hiding (IANALBMSUTDO). This kind of encryption is also called
"subpoena-proof" or "deniable".
There is some previous work in this area. There are two popular approaches,
one is to throw away the encryption key, but store some information that
can be used to recover the key with a considerable computation effort
(several years or so). The concept seems to be risky for obvious reasons,
and is also impractical if the data has to remain accessible before the
projected cracking date.
The other approach is to have a number of containers protected with a number of passwords, of which some but not all might be encrypted data (rubberhose does that). I think its needlessly complex, and usually applied to a storage such as a disk drive.
As such, 2c would be the first tool to implement this functionality in a
reasonable and practical fasion, at least I think so.
Enhancements:
- It was possible to tell a two-file result from a single-file output,
_statistically_. This does not mean the question can be answered for a
particular archive, but single-file archives had a tendency to result
in a slightly larger file, and if you have a number of 2c-protected
files for which the primary password has been obtained, it can be
told how you use 2c. The reason for that was slightly broken compressed
pad length logic.
Severity: medium
- As a cryptographic safeguard, the random pad stream now consists of
a random, compressed file of a random length, followed by true garbage.
This is to mimick second file scenario more closely, so that if the
encryption proves weaker than originally thought, and some statistical
properties of a stream can be deduced, theres no exposure. Version
1 always used a full-length compressed pad, which was silly in that
its not that common to store perfectly-fit secondary files.
Severity: hypotetical issue
- In v1, random chunk would seldom get compressed, because the compression
algorithm resorted to storing uncompressed data if compression would
result in output bigger than input. This is not a flaw per se, but
defeats a minor safeguard intended to mimick a file that would often
be compressible. Now, encryption of all blocks is forced, even though
it might be less efficient.
Severity: hypotetical issue
- Input blocks are now split randomly to avoid placing compression
headers and other known structures at constant locations. This is just
another arbitrary safeguard for the algorithm.
Severity: hypotetical issue
- per Jamess suggestion, I added a counter to the PRNG generator
internal state. This prevents a hypotetical (although *extremely*
unlikely) generator stall scenario. This spectacularly breaks v1
compatibility, blame James ;-)
Severity: low

ll-toxic helps to generate Oracle database functions that return XML strings by allowing you to embed processsing instructions containing PL/SQL code in XML.
Enhancements:
- The API has changed so that encodings other than ISO-8859-1 are now supported.