Second Life Wiki - User contributions [en]

User:SignpostMarv Martin/Webmap API Examples

2010-09-10T06:38:32Z

New Spore:

<div style="font-size:2.0em;">Note: see [http://agni.sl.mapapi.net agni.sl.mapapi.net] for a production example of the refactored JavaScript.</div>

This article covers the refactored javascript for the SLURL [[Map API]] made by {{User2|SignpostMarv Martin}} for Open Hack 2009.

Automated documentation is [http://static.marvulous.co.uk/js/slurl/docs/ available], along with a [http://static.marvulous.co.uk/%C2%B5/js/slurl/mapapi-min.js minified version] of the [http://static.marvulous.co.uk/%C2%B5/js/slurl/mapapi.js Pluggable SLurl Javascript].

== Summary of modifications ==
* All functions were moved into a SLURL object, e.g. SLMap becomes SLURL.map
* Some functions became pluggable
* Some functions were improved for ease of use

== Base HTML ==
Live Example: http://dev.signpostmarv.name/pub/secondlife/slurl.html

<html4strict><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Hack Day '09: Pluggable SLurl!</title>
<meta http-equiv="Content-Type" content="application/xhtml+xml;charset=UTF-8" />
<script src="http://maps.google.com/maps?file=api&v=2&key=[YOUR GOOGLE MAP API KEY HERE]" type="text/javascript"></script>
<script src="http://www.google.com/jsapi?key=[YOUR GOOGLE SEARCH API KEY HERE]" type="text/javascript"></script>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.2.6/jquery.min.js" type="text/javascript"></script>
<script src="http://static.marvulous.co.uk/%C2%B5/js/slurl/mapapi.js" type="text/javascript"></script>

<link rel="stylesheet" type="text/css" href="http://slurl.com/_styles/MAIN.css" />
<script type="text/javascript">
/*<![CDATA[*/
$(function() {
mapInstance = new SLURL.map(document.getElementById('map-container'));
mapInstance.gotoRegion('Hippotropolis');
});
$(document).unload(function() {
// Google script that helps prevent memory leaks
// (we're looking at you when we say that IE!)
GUnload();
/*]]>*/
});
</script>
</head>
<body>
<div id="map-container"></div>
</body>
</html></html4strict>

== Adding a Plugin ==
The key feature of the refactoring (aside from shifting everything into a SLURL object) was to make the SLURL JS "pluggable"- making it easier to extend a SLURL map without needing to create & edit a duplicate of the javascript (which would become difficult to maintain over time the more customisations were made).

Currently, two functions can have callbacks registered with them:
# gotoRegion
# gotoSLURL

The internals of a plugin can be coded however you want them to, but the callback function for the plugin must be structured along these lines:

=== gotoSLURL,gotoRegion ===
<javascript>function my_callBack(slRegionName,x,y,SLMap)
{
// do stuff here
}</javascript>

=== Registering a callback ===
Callback functions are registered to a particular instance of a SLURL map, enabling multiple maps to be used on the same page with different plugins.

* A [http://dev.signpostmarv.name/pub/secondlife/slurl-flickr.html live example of the flickr] is available for demonstration purposes.
* A [http://dev.signpostmarv.name/pub/secondlife/slurl-hacks.html demonstration of multiple plugins] working in tandem is also available.

For example, to enable Marv's Flickr plugin, the following modifications are made to the base HTML;

1) The Flickr plugin is added below mapapi.js: <span><html4strict><script src="http://static.marvulous.co.uk/%C2%B5/js/slurl/plugins/flickr.js" type="text/javascript"></script></html4strict>
2) Some extra CSS is added below MAIN.css: <html4strict><link rel="stylesheet" type="text/css" href="http://dev.signpostmarv.name/pub/secondlife/slurl-hacks.css" /></html4strict>
3) The Flickr plugin is configured: <javascript>SLURL_flickr.apiKey = whatever_your_api_key_is;
SLURL_flickr.groupId = '51035802764@N01'; // Second Life flickr group ID- the same one linked from the official blog. change to suit.
SLURL_flickr.searchMode = 'group'; // the plugin defaults to 'global'- e.g. searching all flickr photos.
SLURL_flickr.resultsPerPage = 32; // the number of thumbnails to display
SLURL_flickr.prependResultsHTML = ''; // Useful for adding a header in before the results.</javascript>
4) The callbacks are registered after the mapInstance has been declared: <javascript> SLURL.addCallBack.gotoSLURL(mapInstance,SLURL_flickr.searchRegion);
SLURL.addCallBack.gotoRegion(mapInstance,SLURL_flickr.searchRegion);</javascript>
5) Finally, some extra HTML for containing the flickr results is added to the body:<html4strict><ul id="slurl-hacks">
<li class="slurl-hack" id="flickr-search"></li>
</ul></html4strict>

== Ease-of-use Improvements ==
=== SLURL.map.panTo ===
A wrapper method has been added to map instances allowing you to safely use SLURL.XYPoint instances to specify co-ordinates.
<javascript>mapInstance.panTo(new SLURL.XYPoint(x,y));</javascript>

=== Adding multiple scripts ===
* SLURL.addScript has been modified to accept an array for the scriptURL argument. Doing so will call SLURL.addScript for each item.
* The load handler function will be called for all scripts, though load order cannot of course be guaranteed.

Pluggable SLURL uses this ease-of-use modification when loading the information sources for the '''Events''' & '''Poly Info''' plugins:
<javascript>SLURL.addScript([
'http://svc.sl.marvulous.co.uk/sl-event-transposer.php',
'http://svc.sl.marvulous.co.uk/sl-mapapi-office-hours.php',
'http://svc.sl.marvulous.co.uk/old-grid-size.js',
'http://svc.sl.marvulous.co.uk/roads.js'
]);</javascript>

=== Adding GPolyline & GPolygon ===
Two new methods have been added to the SLURL namespace:
# SLURL.Polygon
# SLURL.Polyline

Both methods will have property '''GPoly''' when instantiated, allowing them to be added to & removed from a map with ease.

The first argument (used to specify the Poly points) should be an array of SLURL.XYPoint objects.

The '''Poly Info''' plugin uses these methods thusly:

==== SLURL.Polygon ====
<javascript>new SLURL.Polygon(info.points,info.stroke[zoom],info.fill,{},func);</javascript>
==== SLURL.Polyline ====
<javascript>new SLURL.Polyline(info.points,info.stroke[zoom],{},func);</javascript>

=== Adding a Marker ===
'''Key Namespace Alterations'''
# SLURL.map.addMarker (previously SLMap.addMarker)
# SLURL.Img (previously Img)
# SLURL.Icon (previously Icon)
# SLURL.Marker (previously Marker)
# SLURL.XYPoint (previously XYPoint)

SLURL.map.addMarker has been altered for ease of use- the [[Webmap API Examples#Removing a marker|previous syntax]] for adding a single image as a marker required superfluous variables:
<javascript> var yellow_dot_image = new Img("b_map_yellow.gif",9,9);
var yellow_icon = new Icon(yellow_dot_image);
var all_images = [yellow_icon, yellow_icon, yellow_icon, yellow_icon, yellow_icon, yellow_icon];

// creates the marker
marker = new Marker(all_images, new XYPoint(997,1002));
mapInstance.addMarker(marker);</javascript>

The function has been modified in two ways:
# A single string can be passed instead of an array
# Arrays with fewer than 6 items have the first item padded

These two minor alterations simplify things, making the previous example:
<javascript> var yellow_dot_image = new SLURL.Img("b_map_yellow.gif",9,9);
var yellow_icon = new SLURL.Icon(yellow_dot_image);
marker = new Marker(yellow_icon,new SLURL.XYPoint(997,1002));
mapInstance.addMarker(marker);</javascript>

== Multi-Grid Support ==
Some significant modifications were made to allow one core Javascript file to service maps for multiple grids.

Currently the same type of tiles as the Agni map must be used (e.g. multiple regions shrunk and composited into a single image dependant upon zoom level).

A '''really''' under-powered demo of gridConfig is available on [http://dev.signpostmarv.name/pub/secondlife/slurl/gridConfig-demo.html Marv's dev server]- it only changes the background color and starting region (to highlight the background color change).

=== Structure of gridConfig ===
<javascript>
// This is based on the gridConfig for Agni
{
oceanColor : '#1d475f', // background color of the "ocean" (only displayed when no image is available)
defaultRegion : 'Ahern', // default region to direct the map to if none is specified
defaultCoords : // default parcel co-ordinates for use when none are specified or some are missing.
{
x : 128,
y : 128,
z : 20
},
init : function(SLMap) // Called during the instantiation of a map object
{
// do stuff here
},
getTileURL : function(pos, zoom) // function for returning the grid map images
{
// should return an appropriate URL for the specified position & zoom level
},
gotoRegion : function(SLMap,regionName,onLoadHandler) // Should poke external web-service or hard-coded array
{
// do stuff here
},
gotoCoords : function(SLMap,x,y,z) // Should poke external web-service or hard-coded array
{
// do stuff here
}
}</javascript>

=== Specifying a gridConfig ===
The gridConfig object is passed as the third argument when instantiating a map object:

<javascript> m = new SLURL.map(
document.getElementById('map-container'),
{},
gridConfig
);</javascript>

If no gridConfig is specified, the map instance will default to the gridConfig for Agni:
<javascript>//partial snippet from Pluggable SLurl
SLURL.map = function(map_element, map_options,gridConfig)
{
if(gridConfig == undefined)
{
this.gridConfig = SLURL.gridConfig['com.lindenlab.agni'];
}
else
{
this.gridConfig = gridConfig;
}</javascript>

Note: because Agni's grid config is stored in the SLURL object, plugins could be used to replace variables or methods, removing the need to modify the core Javascript when working on new features.

[[Category:Web Service APIs|{{PAGENAME}}]]

Template dictionary python

2010-08-10T07:27:29Z

New Spore:

name this file makepacketdict.py in order to use it

<python>
# uses the client's message_template.msg file to create a dictionary of name and other relevant packet info...
# make sure that message_template.msg has had all leading spaces removed and replaced with the correct number of tabs --I was exceedingly lazy when I wrote this and assumed a consistent tabbing scheme in the template

import re

def makepacketdict():
dict = {}
for line in open("message_template.msg"):
results = re.match("^\t([^\t{}]+.+)",line)
if results:
aline = results.group(1)
aline = aline.split()
if aline[1] == "Fixed":
dict[(aline[1],int(aline[2][8:],16))] = (aline[0],aline[3], aline[4])
else:
dict[(aline[1],int(aline[2]))] = (aline[0],aline[3], aline[4])
return dict
</python>

[[Category: AW Groupies]]

Presence Code Python cmd line

2010-08-09T05:45:35Z

New Spore:

This is a variation of the login presence code that parses the argument list for name, password and eventually url, and uses those if they exist. This allows for automated testing. The URL will eventually be used by a micro-http-server that will accept POST messages from the controlling script and parse them as commands, and return the result of that command in the http response. These could be command line style commands, or some more formal list designed for use with a GUI. This strategy allows for extremely loose coupling of a distributed test harness.

This [[Presence_Code_Python_cmd_line_controller| sample control script]] currently only starts the login script with avatar name and password.

<python>
from struct import *
from zerocode import *
import md5
import xmlrpclib
import sys

import re
import httplib, urllib
from urlparse import urlparse
import socket, sys, time
import uuid
from makepacketdict import makepacketdict

from datetime import datetime

import sys

mypacketdictionary = {}
outputstring = ''
ack_need_list = []

logoutputflag = False

if logoutputflag:
temp = sys.stdout
sys.stdout =open('alog.txt','w')

def login(first, last, passwd, mac):
passwd_md5 = '$1$' + md5.new(passwd).hexdigest()

uri = 'http://127.0.0.1'
uri = 'https://login.agni.lindenlab.com/cgi-bin/login.cgi'
#uri = 'https://login.aditi.lindenlab.com/cgi-bin/login.cgi'
s = xmlrpclib.ServerProxy(uri)

login_details = {
'first': first,
'last': last,
'passwd': passwd_md5,
#'start': 'uri:Sandbox Goguen MONO&133&111&21',
'start': 'uri:Stadt&203&78&23',
'major': '1',
#'minor': '20',
#'patch': '0',
#'build': '86489',
'minor': '19',
'patch': '1',
'build': '4',
'platform': 'Win',
'mac': mac,
'options': [],
'user-agent': '',
'id0': '',
'agree_to_tos': 'Yes',
'viewer_digest': '09d93740-8f37-c418-fbf2-2a78c7b0d1ea'
}
results = s.login_to_simulator(login_details)
print results

return results

def get_caps(results,cap_key, request_keys):

_, netloc, path, _, _, _ = urlparse(results[cap_key])

params = "<llsd><array><string>"+ request_keys[0]+"</string></array></llsd>"
headers = {"content-type": "application/xml"}
conn = httplib.HTTPSConnection(netloc)

conn.request("POST", path, params, headers)
response = conn.getresponse()

data = response.read()
conn.close()
return data

def ExtractCap(cap_result):
return re.search(r"<key>([a-zA-Z_]+)</key><string>([a-zA-Z_:/0-9-.]+)</string>", cap_result).groups()

def scheduleacknowledgemessage(data):
if not (ord(data[0])&0x40):
print "OOOPS! Got asked to ack a message that shouldn't be acked"
else:
ID = data[1:5]
#if (ord(data[0])&0x40) & 0x80: ID = zero_decode_ID(ID)
ack_need_list.append(unpack(">L",ID)[0])
#ack_need_list.append(unpack(">L",data[1:5])[0])
#print "ack needed","insdie schedule ack_need_list", ack_need_list

def packacks():
return "".join(pack("<L", msgnum) for msgnum in ack_need_list)

#def sendacks():
# if len(ack_need_list)>0:

#===============================================================================
# {
# UUIDNameRequest Low NotTrusted Unencoded
# {
# UUIDNameBlock Variable
# { ID LLUUID }
# }
# }
#===============================================================================

def sendUUIDNameRequest(sock, port, host, currentsequence,aUUID):

fix_ID = 0xffff0000 + 235
data_header = pack('>BLB', 0x00,currentsequence,0x00)

packed_data = "".join(uuid.UUID(x).bytes for x in aUUID)

packed_data = data_header + pack("L",fix_ID) + pack(">B",len(aUUID)) + packed_data

sock.sendto(packed_data, (host, port))

def sendRegionHandshakeReply(sock, port, host, currentsequence,agentUUID,sessionUUID):

low_ID = 0xffff0000 + 149
data_header = pack('>BLB', 0x00,currentsequence,0x00)
packed_data = uuid.UUID(agentUUID).bytes+uuid.UUID(sessionUUID).bytes+ pack(">L",0x00)
packed_data = data_header + pack(">L",int(low_ID,16))+packed_data
sock.sendto(packed_data, (host, port))
#print "RegionHandshakeReply", ByteToHex(packed_data)
return

def sendAgentUpdate(sock, port, host, currentsequence, result):

#AgentUpdate

tempacks = packacks()
del ack_need_list[:]
if tempacks == "":
flags = 0x00
else:
flags = 0x10

#print "tempacks is:", ByteToHex(tempacks)

data_header = pack('>BLB', flags,currentsequence,0x00)
packed_data_message_ID = pack('>B',0x04)
packed_data_ID = uuid.UUID(result["agent_id"]).bytes + uuid.UUID(result["session_id"]).bytes
packed_data_QuatRots = pack('<ffff', 0.0,0.0,0.0,0.0)+pack('<ffff', 0.0,0.0,0.0,0.0)
packed_data_State = pack('<B', 0x00)
packed_data_Camera = pack('<fff', 0.0,0.0,0.0)+pack('<fff', 0.0,0.0,0.0)+pack('<fff', 0.0,0.0,0.0)+pack('<fff', 0.0,0.0,0.0)
packed_data_Flags = pack('<fLB', 0.0,0x00,0x00)

encoded_packed_data = zero_encode(packed_data_message_ID+packed_data_ID+packed_data_QuatRots+packed_data_State+packed_data_Camera+packed_data_Flags)

packed_data = data_header + encoded_packed_data+tempacks

# print "sending AgentUpdate to server",ByteToHex(packed_data_header+zero_decode(encoded_packed_data)+ tempacks)

sock.sendto(packed_data, (host, port))

def sendCompletePingCheck(sock, port, host, currentsequence,data,lastPingSent):
# print "data from PingCHeck", ByteToHex(data)

data_header = pack('>BLB', 0x00,currentsequence,0x00)
packed_data_message_ID = pack('>B',0x02)
packed_data = data_header + packed_data_message_ID+pack('>B', lastPingSent)
print "CompletePingCheck packet sent:", ByteToHex(packed_data)
sock.sendto(packed_data, (host, port))

def sendPacketAck(sock, port, host,currentsequence):

tempacks = packacks()
templen = len(ack_need_list)
del ack_need_list[:]
data_header = pack('>BLB',0x00,currentsequence,0x00)
packed_data_message_ID = pack('>L',0xFFFFFFFB)
packed_ack_len = pack('>B',templen)

packed_data = data_header + packed_data_message_ID + packed_ack_len + tempacks
#===============================================================================
# t = datetime.now()
# t.strftime("%H:%M:%S")
# ti = "%02d:%02d:%02d.%06d" % (t.hour,t.minute,t.second,t.microsecond)
# print ti, "PacketAck packet sent:", ByteToHex(packed_data)
#===============================================================================
sock.sendto(packed_data, (host, port))

def sendLogoutRequest(sock, port, host,seqnum,aUUID,sUUID):
packed_data_message_ID = pack('>L',0xffff00fc)
data_header = pack('>BLB', 0x00,seqnum,0x00)
packed_data = uuid.UUID(aUUID).bytes+uuid.UUID(sUUID).bytes+ pack(">L",0x00)

packed_data = data_header + packed_data_message_ID + packed_data
sock.sendto(packed_data, (host, port))

def establishpresence(host, port, circuit_code, result):

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

myAgentID = result["agent_id"]
mySessionID = result["session_id"]

#Sending packet UseCircuitCode <-- Inits the connection to the sim.
data = pack('>BLBL',0x00,0x01,00,0xffff0003) + pack('<L',circuit_code) + uuid.UUID(result["session_id"]).bytes+uuid.UUID(result["agent_id"]).bytes
sock.sendto(data, (host, port))

#ISending packet CompleteAgentMovement <-- establishes the agent's presence
data = pack('>BLBL',0x00,0x02,00,0xffff00f9) + uuid.UUID(result["agent_id"]).bytes + uuid.UUID(result["session_id"]).bytes + pack('<L', circuit_code)
sock.sendto(data, (host, port))

sendAgentUpdate(sock, port, host, 3, result)
aUUID = [result["agent_id"]]
#sendUUIDNameRequest(sock, port, host, 4,aUUID)
#

buf = 100
i = 0
trusted_count = 0
ackable = 0
trusted_and_ackable = 0
ack_need_list_changed = False
seqnum = 5
lastPingSent = 0
trusted = 0
while i<300:
if ack_need_list_changed:
ack_need_list_changed = False
seqnum += 1
sendPacketAck(sock, port, host,seqnum)
#sendAgentUpdate(sock, port, host, seqnum, result)
seqnum += 1
#sendacks()
i += 1
data,addr = sock.recvfrom(buf)
t = datetime.now()
t.strftime("%H:%M:%S")

if not data:
print "Client has exited!"

break
else:
test = ByteToHex(data).split()
#print test
ID = data[6:12]
#print "ID =", ByteToHex(ID)
if ord(data[0])&0x80:
ID = zero_decode_ID(data[6:12])

if ord(data[0])&0x40:
scheduleacknowledgemessage(data);
ack_need_list_changed = True
#print "ID =", ByteToHex(ID)
#print "ID =", unpack(">L", ID[:4])
if ID[0] == '\xFF':
if ID[1] == '\xFF':
if ID[2] == '\xFF':
myentry = mypacketdictionary[("Fixed" , int(ByteToHex(ID[0:4]).replace(' ', ''),16))]
if myentry[1] == "Trusted":
trusted += 1;
ti = "%02d:%02d:%02d.%06d" % (t.hour,t.minute,t.second,t.microsecond)
print ti, "Message #", i, "trusted count is", trusted,"Flags: 0x" + test[0], myentry, "sequence #", unpack(">L",data[1:5])

#if myentry[1] == "Trusted": trusted_count += 1;print "number of trusted messages =", trusted_count
#if ord(data[0])&0x40 and myentry[1] == "Trusted": trusted_and_ackable += 1; print "trusted_and_ackable =", trusted_and_ackable
#if ord(data[0])&0x40: ackable += 1; print "number of ackable messages = ", ackable
else:
myentry = mypacketdictionary[("Low",int(ByteToHex(ID[2:4]).replace(' ', ''),16))]
if myentry[1] == "Trusted":
trusted += 1;
ti = "%02d:%02d:%02d.%06d" % (t.hour,t.minute,t.second,t.microsecond)
print ti, "Message #", i,"trusted count is", trusted,"Flags: 0x" + test[0], myentry, "sequence #", unpack(">L",data[1:5])
if myentry[0] == "UUIDNameReply":
pass
#print ByteToHex(data)
#print data[:28]
#print data[28:36],data[38:45]
elif myentry[0] == "RegionHandshake":
sendRegionHandshakeReply(sock, port, host, seqnum,result["agent_id"],result["session_id"])
seqnum += 1

#if myentry[1] == "Trusted": trusted_count += 1;print "number of trusted messages =", trusted_count
#if ord(data[0])&0x40 and myentry[1] == "Trusted": trusted_and_ackable += 1; print "trusted_and_ackable =", trusted_and_ackable
#if ord(data[0])&0x40: ackable += 1; print "number of ackable messages = ", ackable
else:
myentry = mypacketdictionary[("Medium", int(ByteToHex(ID[1:2]).replace(' ', ''),16))]
if myentry[1] == "Trusted":
trusted += 1;
ti = "%02d:%02d:%02d.%06d" % (t.hour,t.minute,t.second,t.microsecond)
print ti, "Message #", i,"trusted count is", trusted,"Flags: 0x" + test[0], myentry, "sequence #", unpack(">L",data[1:5])

#if myentry[1] == "Trusted": trusted_count += 1;print "number of trusted messages =", trusted_count
#if ord(data[0])&0x40 and myentry[1] == "Trusted": trusted_and_ackable += 1; print "trusted_and_ackable =", trusted_and_ackable
#if ord(data[0])&0x40: ackable += 1; print "number of ackable messages = ", ackable
else:
myentry = mypacketdictionary[("High", int(ByteToHex(ID[0]), 16))]
if myentry[0] == "StartPingCheck":
print "data from StartPingCheck", test
sendCompletePingCheck(sock, port, host, seqnum,data,lastPingSent)
lastPingSent += 1
seqnum += 1

if myentry[1] == "Trusted":
trusted += 1;
ti = "%02d:%02d:%02d.%06d" % (t.hour,t.minute,t.second,t.microsecond)

print ti, "Message #", i,"trusted count is", trusted,"Flags: 0x" + test[0], myentry, "sequence #", unpack(">L",data[1:5])

#if myentry[1] == "Trusted": trusted_count += 1;print "number of trusted messages =", trusted_count
#if ord(data[0])&0x40 and myentry[1] == "Trusted": trusted_and_ackable += 1; print "trusted_and_ackable =", trusted_and_ackable
#if ord(data[0])&0x40: ackable += 1; print "number of ackable messages = ", ackable

sendLogoutRequest(sock, port, host,seqnum,myAgentID,mySessionID)
sock.close()
print "final number of trusted messages =", trusted_count

argsList = sys.argv

if len(argsList) == 4: # POST handler not implemented yet
myResult = login(argsList[1], argsList[2], argsList[3], "01:02:03:04:05:06")
else: #simple hard-coded startup
myResult = login("first", "last", "password", "01:02:03:04:05:06") #note fake MAC
mypacketdictionary = makepacketdict()

myhost = myResult["sim_ip"]
myport = myResult["sim_port"]
mycircuit_code = myResult["circuit_code"]

establishpresence(myhost, myport, mycircuit_code, myResult)

#cap_out = get_caps(result,"seed_capability", ["ChatSessionRequest"])

</python>
[[Category: AW Groupies]]

Makepacketdict

2010-08-09T02:42:34Z

New Spore:

brain-dead import. While it should work as-is for testing, the parsing requires you eliminate all extraneous spaces in the white space in "message_template.msg" before the "{" and replace it with tabs

<python>
import re

def makepacketdict():
dict = {}
for line in open("message_template.msg"):
results = re.match("^\t([^\t{}]+.+)",line)
if results:
aline = results.group(1)
aline = aline.split()
if aline[1] == "Fixed":
dict[(aline[1],aline[2])] = (aline[0],aline[3], aline[4])

#print (aline[1],aline[2])
#print (aline[1],"0x"+aline[2]), dict[(aline[1],"0x"+aline[2])]
#dict[(aline[1],int(aline[2][8:],16))] = (aline[0],aline[3], aline[4])
else:
dict[(aline[1],int(aline[2]))] = (aline[0],aline[3], aline[4])
return dict

</python>
[[Category: AW Groupies]]

XTEA Strong Encryption Implementation

2010-07-06T00:10:37Z

New Spore: /* XTEA LSL PHP */

{{LSL Header}}{{RightToc}}

XTEA Strong Encryption Implementation - Linden Scripting Language (LSL)
Version 1.0

= Contributors =
*[http://morsedillon.com/ Morse Dillon], Author, (morseATmorsedillon.com)
*{{User|Strife Onizuka}} (blindwandererATgmail.com)
*[http://dedricmauriac.wordpress.com/ Dedric Mauriac], Contributor (dedric.mauriacATgmail.com)
*{{User|JB_Kraft}} (php 5 class)

= License =
This work is licensed under a [http://creativecommons.org/licenses/by/3.0/ Creative Commons Attribution-Share Alike 3.0 Unported License]

You are free:
*'''to Share''' — to copy, distribute and transmit the work
*'''to Remix''' — to adapt the work

Under the following conditions
*'''Attribution.''' You must attribute the work in the manner specified by the author or licensor (but not in any way that suggests that they endorse you or your use of the work).

# For any reuse or distribution, you must make clear to others the license terms of this work. The best way to do this is with [http://creativecommons.org/licenses/by/3.0/ a link to this web page].
# Any of the above conditions can be waived if you get permission from the copyright holder.
# Nothing in this license impairs or restricts the author's moral rights.

= Disclaimer =
This program is distributed in the hope that it will be useful, but '''WITHOUT ANY WARRANTY'''; without even the implied warranty of '''MERCHANTABILITY''' or '''FITNESS FOR A PARTICULAR PURPOSE'''.

'''IF YOU READ ONE THING IN HERE, READ THIS'''

It is VERY important to remember that there is no such thing as ''cookbook cryptography''! Simply using this cypher does not guarantee security. Security is an end-to-end concern and responsibility lies with you to thoroughly examine your project from all possible angles if valuable data is at risk. If you doubt this, ask any thief how they'd rather break into your house - futzing about with picking a high-security deadbolt on the front door or walking in through the back door that you left open.

= Documentation =
Included at the end of this source listing is a small bit of example code that shows the usage. If you wish to include this implementation in your own work, just replace the example code with your own. Also, please do not reuse or redistribute this work without including the above text attributing this code to its author Morse Dillon, the above GPL statement, and this documentation.

This is an implementation of the XTEA (eXtended Tiny Encryption Algorithm) block cypher. (X)TEA is a very good choice of cipher when security is important but computational power is limited. Although I did a lot of work on this implementation, enormous amounts of credit must be given to the creators of the algorithm and those who came before me to implement it in other languages and computing environments.

''If you do decide to use this code in a project, I'd appreciate hearing about it. You can reach me by e-mail at: morseATmorsedillon.com''

== About TEA ==

The Tiny Encryption Algorithm ([http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm TEA]), was originally designed by David Wheeler and Roger Needham of the Cambridge Computer Laboratory. The [http://www.ftp.cl.cam.ac.uk/ftp/papers/djw-rmn/djw-rmn-tea.html algorithm] itself is not subject to any patents. While the original TEA was found to have some minor weaknesses, the eXtended Tiny Encryption Algorithm ([http://en.wikipedia.org/wiki/XTEA XTEA]) implemented herein addresses these.

''NOTE: XTEA has been superseded by Corrected Block TEA ([http://en.wikipedia.org/wiki/XXTEA XXTEA])''

TEA and its derivatives consist of 64-bit block [http://en.wikipedia.org/wiki/Feistel_cipher Feistel network] with a 128-bit key. This implementation uses six cycles, or rounds, which is less than one would like but still provides a reasonable level of security (16 is sufficient while 8 is enough for most applications). Six is said to achieve theoretically good dispersion, but should more security be desired the number of cycles can easily be modified by changing the CYCLES global variable. Due to the low execution speed of LSL scripts, it's suggested to make this as low as your comfort level allows. Encryption time scales linearly with the number of cycles.

== About this implementation ==
This is a bare bones implementation, and is meant to be included in the body of the script needing encryption facilities or wrapped in a link message handler. If the latter approach is desired, care should be taken to only send link messages to the prim containing this implementation. If ALL_PRIMS is used as the destination, one could link a link message listener to the object and intercept clear-text communications.

If you plan to place this code into the same script as that needing encryption facilities, you need only call the following functions:

<lsl>
string Encrypt(string clearText)
string Decrypt(string cypherText)
</lsl>

Simple as that.

This implementation does not provide any secure key exchange, so in terms of key generation and exchange you're on your own.

The 128-bit key is contained in four LSL integers: KEY1, KEY2, KEY3, and KEY4. These are global variables at the beginning of the source and can be set using a method that works for you.

==Changes==

===Version 1.1===
*Changed to treat [[Right Shift]] as if integers were unsigned

===Version 1.0a - Alpha===
*General optimization to run faster and use less bytecode.
*Encrypt: Pad works differently, no longer extra characters appended to the output.
*TEAEncrypt: Changed the return type
*ord: Added null support.

===Version 1.0===
*Initial Release

== Future Recommendations ==
*Support [[UTF-8]]
*Output to [[Base64]] instead of [[Hex]] strings
*Append hash to the message to verify integrity of data
*Hash clear-text passwords into 128 bit keys
*Upgrade to XXTEA

= Code =

== Original ==
<lsl>

//XTEA Strong Encryption Implementation - Linden Scripting Language (LSL)
//Version 1.0
//Copyright (C) 2007 by Morse Dillon (morseATmorsedillon.com)
//
//This program is free software; you can redistribute it and/or
//modify it under the terms of the GNU General Public License
//as published by the Free Software Foundation; either version 2
//of the License, or (at your option) any later version.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with this program; if not, write to the Free Software
//Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
//02110-1301, USA.
//========================================================================
//
//Included at the end of this source listing is a small bit of example
//code that shows the usage. If you wish to include this implementation
//in your own work, just replace the example code with your own. Also,
//please do not reuse or redistribute this work without including the
//above text attributing this code to its author Morse Dillon, the above
//GPL statement, and this documentation.
//
//This is an implentation of the XTEA (eXtended Tiny Encryption Algorithm)
//block cypher. (X)TEA is a very good choice of cipher when security
//is important but computational power is limited. Although I did a
//lot of work on this implementation, enormous amounts of credit must
//be given to the creators of the algorithm and those who came before
//me to implement it in other languages and computing environments.
//
//***If you do decide to use this code in a project, I'd appreciate
//hearing about it. You can reach me by e-mail at:
//morseATmorsedillon.com
//
//
//ABOUT TEA AND XTEA
//------------------
//TEA was originally designed by David Wheeler and Roger Needham
//of the Cambridge Computer Laboratory. The algorithm itself is not
//subject to any patents. While the original TEA was found to have
//some minor weaknesses, XTEA (implemented herein) addresses these.
//
//TEA and its derivatives consist of 64-bit block Feistel network
//with a 128-bit key. This implementation uses six cycles, or rounds,
//which is less than one would like but still provides a reasonable
//level of security (16 is sufficient while 8 is enough for most
//applications). Six is said to achieve theoretically good dispersion,
//but should more security be desired the number of cycles can easily be
//modified by changing the CYCLES global variable. Due to the low
//execution speed of LSL scripts, it's suggested to make this as low as
//your comfort level allows. Encryption time scales linearly with the
//number of cycles.
//
//For more information about XTEA, see the following:
//
//Original Paper by Walker and Needham
//http://www.ftp.cl.cam.ac.uk/ftp/papers/djw-rmn/djw-rmn-tea.html
//
//Wikipedia on TEA
//http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm
//
//
//ABOUT THIS IMPLEMENTATION
//-------------------------
//This is a barebones implementation, and is meant to be included in
//the body of the script needing encryption facilities or wrapped
//in a link message handler. If the latter approach is desired, care
//should be taken to only send link messages to the prim containing
//this implementation. If ALL_PRIMS is used as the destination,
//one could link a link message listener to the object and intercept
//cleartext communications.
//
//If you plan to place this code into the same script as that needing
//encryption facilities, you need only call the following functions:
//
//string Encrypt(string cleartext)
//string Decrypt(string cyphertext)
//
//Simple as that.
//
//This implementation does not provide any secure key exchange, so in
//terms of key generation and exchange you're on your own.
//
//The 128-bit key is contained in four LSL integers: KEY1, KEY2, KEY3,
//and KEY4. These are global variables at the beginning of the source
//and can be set using a method that works for you.
//
//
//**************IF YOU READ ONE THING IN HERE, READ THIS*******************
//It is VERY important to remember that there is no such thing as
//'cookbook cryptography'! Simply using this cypher does not guarantee
//security. Security is an end-to-end concern and responsibility lies
//with you to thoroughly examine your project from all possible angles
//if valuable data is at risk. If you doubt this, ask any thief how they'd
//rather break into your house - futzing about with picking a high-security
//deadbolt on the front door or walking in through the back door that you
//left open.

//******************USER-CONFIGURABLE GLOBALS BEGIN HERE*******************

//ENCRYPTION KEYS KEY[1-4]
//These together make up the 128-bit XTEA encryption key. See the above
//documentation for details. Whatever you do, don't leave them as the default.
integer KEY1 = 11111111;
integer KEY2 = 22222222;
integer KEY3 = 33333333;
integer KEY4 = 44444444;

//DEBUG_FLAG
//If set to 1, will cause debug text to be printed containing some
//intermediate cleartext/cyphertext and the resultant cyphertext/cleartext.
//Do not leave this enabled in production environments!!!!
integer DEBUG_FLAG = 0;

//COMM_CHANNEL
//Specifies which channel should be used for debug and test harness communication.
integer COMM_CHANNEL = 0;

//CYCLES
//Specifies the number of rounds to be used. See the above documentation for
//details.
integer CYCLES = 6;

//******************USER-CONFIGURABLE GLOBALS END HERE*********************

//Other Globals
list cypherkey = [];
integer delta = 0x9E3779B9;

//Function: ord
//Returns the index of an ASCII character
integer ord(string chr)
{
string ASCII = " \n !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
if(llStringLength(chr) != 1) return -1;
if(chr == " ") return 32;
return llSubStringIndex(ASCII, chr);
}

//Function: chr
//Returns the ASCII character correspondent to index i
string chr(integer i)
{
string ASCII = " \n !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
i %= 127;
return llGetSubString(ASCII, i, i);
}

//Function: DWord2Hex
//Converts a dword containted in a LSL integer to hexadecimal format.
string DWord2Hex(integer m){

string result;
integer i = 0;
integer index = 0;

//Define character string [0-F] for use in building the hex.
string characters = "0123456789ABCDEF";

//Step through 8 times, for a total of 32 bits, 8 nibbles, and 8 hexadecimal digits.
for (i = 0; i < 8; i++){
//Get a nibble by right-shifting and masking off 4 bits.
index = (m >> (i * 4)) & 0xF;
//Grab character from the characters string at index position and add it to the result string.
result = llInsertString(result, 0, llGetSubString(characters,index,index));
}

return result;
}

//Function: Hex2DWword
//Converts a string containing a hexadecimal number to a dword contained in a LSL integer.
integer Hex2DWord(string m){
integer result = 0;
integer i = 0;
string digit;
integer value;
integer index;

string characters = "0123456789ABCDEF";

for (i = 0; i < 8; i++){

index = 8 - (i + 1);
digit = llGetSubString(m,index,index);

value = llSubStringIndex(characters, digit);

result = result | value << (i * 4);

}

return result;
}

//Function: Encrypt
//Takes cleartext string, pads and bitpacks it, then encrypts it using TEAEncrypt().
string Encrypt(string cleartext){

//Initialize variables.
integer dword1 = 0;
integer dword2 = 0;
integer cyphertext_numeric;
list cypherblock;
string cyphertext = "";

//Pad cleartext string to the nearest multiple of 8.
while(llStringLength(cleartext) & 0x7) {
cleartext += " ";
}

//Define more variables pertaining to while loop.
integer stringlength = llStringLength(cleartext);
integer i=0;
integer character;

//Step through cleartext string, encrypting it in 64-bit (8 character) blocks.
while (i < stringlength){

//Pack dword1 with 4 bytes. Do so by bit-shifting in each character.
//4th byte winds up in the most-significant position.
dword1 = ord(llGetSubString(cleartext,i,i));
i++;
dword1 = dword1 | (ord(llGetSubString(cleartext,i,i)) << 8);
i++;
dword1 = dword1 | (ord(llGetSubString(cleartext,i,i)) << 16);
i++;
dword1 = dword1 | (ord(llGetSubString(cleartext,i,i)) << 24);
i++;

//Do it again, this time for dword2
dword2 = ord(llGetSubString(cleartext,i,i));
i++;
dword2 = dword2 | ord(llGetSubString(cleartext,i,i)) << 8;
i++;
dword2 = dword2 | ord(llGetSubString(cleartext,i,i)) << 16;
i++;
dword2 = dword2 | ord(llGetSubString(cleartext,i,i)) << 24;
i++;

//Call TEAencrypt() with dword1, dword2, and the cypher key and store result in cypherblock.
cypherblock = TEAEncrypt(dword1,dword2,cypherkey);

//Convert dword values from cypherblock to hex and append to cyphertext.
cyphertext = cyphertext + DWord2Hex(llList2Integer(cypherblock,0)) + DWord2Hex(llList2Integer(cypherblock,1));

//Reset variables for the next round, just to be safe.
dword1 = 0;
dword2 = 0;
cypherblock = [];

if(DEBUG_FLAG){
llOwnerSay("Pre-Crypt DWords: " + (string)dword1 + "," + (string)dword2);
llOwnerSay("Post-Crypt DWords: " + (string)llList2Integer(cypherblock,1) + "," + (string)llList2Integer(cypherblock,2));
llOwnerSay("Post-Crypt Hex: " + DWord2Hex(llList2Integer(cypherblock,1)) + "," + DWord2Hex(llList2Integer(cypherblock,2)));
}

}

return cyphertext;
}

//Function: Decrypt
//Takes cyphertext, decrypts it with TEADecrypt(), and unpacks it into a string.
string Decrypt(string cyphertext){

//Initialize variables.
string hexvalue1 = "";
string hexvalue2 = "";
integer dword1 = 0;
integer dword2 = 0;
list clearblock = []; //res
string cleartext = "";
integer i;

//Step through cyphertext string, descrypting it block by block.
while (i < llStringLength(cyphertext)){

//Pull first 32 bits worth of hexadecimal into hexvalue1
hexvalue1 += llGetSubString(cyphertext,i,i + 7);
i = i + 8;

//Pull second 32 bits worth of hexadecimal into hexvalue2
hexvalue2 += llGetSubString(cyphertext,i,i + 7);
i = i + 8;

//Convert hexvalues to dwords contained in LSL integers.
dword1 = Hex2DWord(hexvalue1);
dword2 = Hex2DWord(hexvalue2);

//Call TEADecrypt() with dword1, dword2, and the cypher key and store result in clearblock list.
clearblock = TEADecrypt(dword1, dword2, cypherkey);

//Append first 4 characters of ASCII to cleartext string.
//This is done by pulling the decrypted dwords from the clearblock list and looking up their ASCII values.
cleartext += chr( llList2Integer(clearblock,0) & 0x000000FF);
cleartext += chr( (llList2Integer(clearblock,0) & 0x0000FF00) >> 8);
cleartext += chr( (llList2Integer(clearblock,0) & 0x00FF0000) >> 16);
cleartext += chr( (llList2Integer(clearblock,0) & 0xFF000000) >> 24);

//Append second 4 characters of ASCII to cleartext string.
cleartext += chr( llList2Integer(clearblock,1) & 0x000000FF);
cleartext += chr( (llList2Integer(clearblock,1) & 0x0000FF00) >> 8);
cleartext += chr( (llList2Integer(clearblock,1) & 0x00FF0000) >> 16);
cleartext += chr( (llList2Integer(clearblock,1) & 0xFF000000) >> 24);

//Reset variables for the next two blocks of decrypt.
hexvalue1 = "";
hexvalue2 = "";
dword1 = 0;
dword2 = 0;
clearblock = [];

if(DEBUG_FLAG){
llOwnerSay("Pre-Decrypt Hex: " + hexvalue1 + "," + hexvalue2);
llOwnerSay("Pre-Decrypt DWords: " + (string)dword1 + "," + (string)dword2);
llOwnerSay("Post-Decrypt DWords: " + (string)llList2Integer(clearblock,1) + "," + (string)llList2Integer(clearblock,2));
}

}

return cleartext;
}

//Function: TEAEncrypt
//This is the implementation of XTEA proper. It takes a block of cleartext
//consisting of two dwords contained in LSL integers and a 128-bit key
//contained in an LSL list of 4 integers. The function then returns
//the cyphertext in an LSL list of two integers.
list TEAEncrypt(integer dword1, integer dword2,list cypherkey){

list cryptlist = [];

//Set n to the number of cycles given in the CYCLES global variable
integer n = CYCLES;

integer sum = 0;

//Operate for the specified number of cycles.
while (n-- > 0){
dword1 = dword1 + ( ( dword2 << 4 ^ ((dword2 >> 5) & 0x07FFFFFF) ) + dword2 ^ sum + llList2Integer(cypherkey, (sum & 3) ) );
sum += delta;
dword2 = dword2 + ( ( dword1 << 4 ^ ((dword1 >> 5) & 0x07FFFFFF) ) + dword1 ^ sum + llList2Integer(cypherkey, ((sum >> 11) & 3) ) );
}

cryptlist = [dword1,dword2];

return cryptlist;
}

//Function: TEADecrypt
//This is the implementation of XTEA proper. It takes a block of cyphertext
//consisting of two dwords contained in LSL integers and a 128-bit key
//contained in an LSL list of 4 integers. The function then returns
//the cleartext in an LSL list of two integers.
list TEADecrypt(integer dword1, integer dword2,list cypherkey){

list cryptlist = [];

//Set n to the number of cycles given in the CYCLES global variable
integer n = CYCLES;

integer sum = delta * CYCLES;

//Operate for the specified number of cycles.
while (n-- > 0){
dword2 = dword2 - ( ( dword1 << 4 ^ ((dword1 >> 5) & 0x07FFFFFF) ) + dword1 ^ sum + llList2Integer(cypherkey, ((sum >> 11) & 3) ) );
sum -= delta;
dword1 = dword1 - ( ( dword2 << 4 ^ ((dword2 >> 5) & 0x07FFFFFF) ) + dword2 ^ sum + llList2Integer(cypherkey, (sum & 3) ) );
}

cryptlist = [dword1,dword2];
return cryptlist;
}
</lsl>

== Usage Example ==
Listens on COMM_CHANNEL for a message and encrypts it, then turns around and decrypts the resultant cypher-text. Object than says the encrypted and decrypted messages to the owner.
<lsl>
default
{
state_entry()
{
llListen(COMM_CHANNEL, "", NULL_KEY, "");
cypherkey = [KEY1,KEY2,KEY3,KEY4];
}

listen(integer channel, string name, key id, string message)
{
string temp_cyphertext = Encrypt(message);

string temp_cleartext = Decrypt(temp_cyphertext);

llOwnerSay("\nOriginal Cleartext: " + message + "\nCyphertext: " + temp_cyphertext + "\nDecrypted Cleartext: " + temp_cleartext);
}
}
</lsl>

== Optimized ==
This version is untested but if it works should run faster (and be able to handle larger strings).

<lsl>
// Include the documentation comments from above (separated here only for easier management)

//XTEA Strong Encryption Implementation - Linden Scripting Language (LSL)
//Version 1.0a Alpha
//Copyright (C) 2007 by Strife Onizuka (blindwandererATgmail.com)
//
//Version 1.0
//Copyright (C) 2007 by Morse Dillon (morseATmorsedillon.com)
//
//This program is free software; you can redistribute it and/or
//modify it under the terms of the GNU General Public License
//as published by the Free Software Foundation; either version 2
//of the License, or (at your option) any later version.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with this program; if not, write to the Free Software
//Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
//02110-1301, USA.
//========================================================================
//
//Included at the end of this source listing is a small bit of example
//code that shows the usage. If you wish to include this implementation
//in your own work, just replace the example code with your own. Also,
//please do not reuse or redistribute this work without including the
//above text attributing this code to its author Morse Dillon, the above
//GPL statement, and this documentation.
//
//This is an implentation of the XTEA (eXtended Tiny Encryption Algorithm)
//block cypher. (X)TEA is a very good choice of cipher when security
//is important but computational power is limited. Although I did a
//lot of work on this implementation, enormous amounts of credit must
//be given to the creators of the algorithm and those who came before
//me to implement it in other languages and computing environments.
//
//***If you do decide to use this code in a project, I'd appreciate
//hearing about it. You can reach me by e-mail at:
//morseATmorsedillon.com
//
//
//ABOUT TEA AND XTEA
//------------------
//TEA was originally designed by David Wheeler and Roger Needham
//of the Cambridge Computer Laboratory. The algorithm itself is not
//subject to any patents. While the original TEA was found to have
//some minor weaknesses, XTEA (implemented herein) addresses these.
//
//TEA and its derivatives consist of 64-bit block Feistel network
//with a 128-bit key. This implementation uses six cycles, or rounds,
//which is less than one would like but still provides a reasonable
//level of security (16 is sufficient while 8 is enough for most
//applications). Six is said to achieve theoretically good dispersion,
//but should more security be desired the number of cycles can easily be
//modified by changing the CYCLES global variable. Due to the low
//execution speed of LSL scripts, it's suggested to make this as low as
//your comfort level allows. Encryption time scales linearly with the
//number of cycles.
//
//For more information about XTEA, see the following:
//
//Original Paper by Walker and Needham
//http://www.ftp.cl.cam.ac.uk/ftp/papers/djw-rmn/djw-rmn-tea.html
//
//Wikipedia on TEA
//http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm
//
//
//ABOUT THIS IMPLEMENTATION
//-------------------------
//This is a barebones implementation, and is meant to be included in
//the body of the script needing encryption facilities or wrapped
//in a link message handler. If the latter approach is desired, care
//should be taken to only send link messages to the prim containing
//this implementation. If ALL_PRIMS is used as the destination,
//one could link a link message listener to the object and intercept
//cleartext communications.
//
//If you plan to place this code into the same script as that needing
//encryption facilities, you need only call the following functions:
//
//string Encrypt(string cleartext)
//string Decrypt(string cyphertext)
//
//Simple as that.
//
//This implementation does not provide any secure key exchange, so in
//terms of key generation and exchange you're on your own.
//
//The 128-bit key is contained in four LSL integers: KEY1, KEY2, KEY3,
//and KEY4. These are global variables at the beginning of the source
//and can be set using a method that works for you.
//
//
//CHANGES
//-------
//
//1.0a - Alpha
//*General optimization to run faster and use less bytecode.
//*Encrypt: Pad works differently, no longer extra characters appended to the output.
//*TEAEncrypt: Changed the return type
//*ord: Added null support.
//
//1.0
//*Initial Release
//
//
//FUTURE CHANGES
//--------------
//
//It would be nice if it supported UTF-8; but adding that would be alot
//of work. The main issue is the decoding, the bytes would have to be
//reassembled into characters. It would be time consuming. Another possibility
//would be to implement XTEA to output to BASE64 instead of hex strings (also
//time consuming to implement).
//
//
//**************IF YOU READ ONE THING IN HERE, READ THIS*******************
//It is VERY important to remember that there is no such thing as
//'cookbook cryptography'! Simply using this cypher does not guarantee
//security. Security is an end-to-end concern and responsibility lies
//with you to thoroughly examine your project from all possible angles
//if valuable data is at risk. If you doubt this, ask any thief how they'd
//rather break into your house - futzing about with picking a high-security
//deadbolt on the front door or walking in through the back door that you
//left open.

//******************USER-CONFIGURABLE GLOBALS BEGIN HERE*******************

//ENCRYPTION KEYS KEY[1-4]
//These together make up the 128-bit XTEA encryption key. See the above
//documentation for details. Whatever you do, don't leave them as the default.
//Don't be stupid and make it obvious like your av's key.
integer KEY1 = 11111111;
integer KEY2 = 22222222;
integer KEY3 = 33333333;
integer KEY4 = 44444444;

//COMM_CHANNEL
//Specifies which channel should be used for debug and test harness communication.
integer COMM_CHANNEL = 0;

//CYCLES
//Specifies the number of rounds to be used. See the above documentation for
//details.
integer CYCLES = 6;

//******************USER-CONFIGURABLE GLOBALS END HERE*********************

//Other Globals
list cypherkey = [];
integer delta = 0x9E3779B9;

string ASCII = " \n !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
string characters = "0123456789ABCDEF";

//Function: ord
//Returns the index of an ASCII character
integer ord(string chr)
{
if(chr)
{
if(llStringLength(chr) > 1) return -1;
if(chr == " ") return 32;
return llSubStringIndex(ASCII, chr);
}
return 0;
}

//Function: chr
//Returns the ASCII character correspondent to index i
string chr(integer i)
{
if(i)
return llGetSubString(ASCII, i %= 127, i);
return "";
}

//Function: DWord2Hex
//Converts a dword contained in a LSL integer to hexadecimal format.
string DWord2Hex(integer m)
{
string result;
integer i = 0;

//Define character string [0-F] for use in building the hex.
//Step through 8 times, for a total of 32 bits, 8 nibbles, and 8 hexadecimal digits.
do{
integer index = (m >> i) & 0xF;
result = llGetSubString(characters, index, index) + result;
}while((i += 4) < 32);
return result;
}

//Function: Encrypt
//Takes cleartext string, pads and bitpacks it, then encrypts it using TEAEncrypt().
string Encrypt(string cleartext)
{
string cyphertext = "";
integer i = llStringLength(cleartext);
if((i += (0x7 & -i)))//Pad cleartext string to the nearest multiple of 8.
{
//Step through cleartext string backwords, encrypting it in 64-bit (8 character) blocks.
do{
//i=~-i is the same as --i, just a bit faster and lighter on bytecode; requires one less stack manipulation.
//Pack dword1 with 4 bytes. Do so by bit-shifting in each character.
//4th byte winds up in the most-significant position.
integer dword2 = ( ord(llGetSubString(cleartext,i=~-i,i)) ) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 8 ) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 16) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 24) ;

//Do it again, this time for dword1
integer dword1 = ( ord(llGetSubString(cleartext,i=~-i,i)) ) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 8 ) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 16) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 24) ;

//Call TEAencrypt() with dword1, dword2, and the cypher key and store result in cypherblock.

//Convert dword values from cypherblock to hex and append to cyphertext.
cyphertext = TEAEncrypt(dword1,dword2,cypherkey) + cyphertext;
}while(i);
}
return cyphertext;
}

//Function: Decrypt
//Takes cyphertext, decrypts it with TEADecrypt(), and unpacks it into a string.
string Decrypt(string cyphertext){

//Initialize variables.
string cleartext = "";
integer i = -llStringLength(cyphertext);

//Step through cyphertext string, decrypting it block by block.
if((i -= (0xF & i)))//Pad cyphertext string to the nearest multiple of 16.
{
do
{

//Convert hexvalues to dwords contained in LSL integers.
//Call TEADecrypt() with dword1, dword2, and the cypher key and store result in clearblock list.
list clearblock = TEADecrypt((integer)("0x"+llGetSubString(cyphertext,i, ~-(i -= 8))),
(integer)("0x"+llGetSubString(cyphertext,i, ~-(i -= 8))), cypherkey);

//Append first 4 characters of ASCII to cleartext string.
//This is done by pulling the decrypted dwords from the clearblock list and looking up their ASCII values.
integer t = llList2Integer(clearblock,1);
cleartext += chr( (t ) & 0xFF) +
chr( (t >> 8 ) & 0xFF) +
chr( (t >> 16) & 0xFF) +
chr( (t = llList2Integer(clearblock,0) >> 24) & 0xFF) +
chr( (t ) & 0xFF) +
chr( (t >> 8 ) & 0xFF) +
chr( (t >> 16) & 0xFF) +
chr( (t >> 24) & 0xFF) ;
}while(i);
}
return cleartext;
}

//Function: TEADecrypt
//This is the implementation of XTEA proper. It takes a block of cleartext
//consisting of two dwords contained in LSL integers and a 128-bit key
//contained in an LSL list of 4 integers. The function then returns
//the cyphertext in an LSL list of two integers.
string TEAEncrypt(integer dword1, integer dword2, list cypherkey_)
{
if(CYCLES > 0)//$[E20011] /*lslint ignore*/
{
//Set n to the number of cycles given in the CYCLES global variable
integer n = CYCLES;
integer sum = 0;
//Operate for the specified number of cycles.
do{
dword1 = dword1 + ( ( dword2 << 4 ^ dword2 >> 5 ) + dword2 ^ sum + llList2Integer(cypherkey_, (sum & 3) ) );
dword2 = dword2 + ( ( dword1 << 4 ^ dword1 >> 5 ) + dword1 ^ sum + llList2Integer(cypherkey_, ((sum += delta) >> 11 & 3) ) );
}while (n = ~-n);
}
return DWord2Hex(dword1) + DWord2Hex(dword2);
}

//Function: TEADecrypt
//This is the implementation of XTEA proper. It takes a block of cyphertext
//consisting of two dwords contained in LSL integers and a 128-bit key
//contained in an LSL list of 4 integers. The function then returns
//the cleartext in an LSL list of two integers.
list TEADecrypt(integer dword1, integer dword2,list cypherkey_)
{
if(CYCLES > 0)//$[E20011] /*lslint ignore*/
{
//Set n to the number of cycles given in the CYCLES global variable
integer n = CYCLES;
integer sum = delta * CYCLES;
//Operate for the specified number of cycles.
do{
dword2 = dword2 - ( ( dword1 << 4 ^ dword1 >> 5 ) + dword1 ^ sum + llList2Integer(cypherkey_, (sum >> 11 & 3) ) );
dword1 = dword1 - ( ( dword2 << 4 ^ dword2 >> 5 ) + dword2 ^ sum + llList2Integer(cypherkey_, ((sum -= delta) & 3) ) );
}while (n = ~-n);
}
return [dword1,dword2];
}

//XTEA Usage Example
//Listens on COMM_CHANNEL for a message and encrypts it, then turns around and decrypts the resultant cyphertext.
//Object than says the encrypted and decrypted messages to the owner.
default
{
state_entry()
{
llListen(COMM_CHANNEL, "", NULL_KEY, "");
cypherkey = [KEY1,KEY2,KEY3,KEY4];
}

listen(integer channel, string name, key id, string message)
{
string temp_cyphertext = Encrypt(message);

string temp_cleartext = Decrypt(temp_cyphertext);

llOwnerSay("\nOriginal Cleartext: " + message + "\nCyphertext: " + temp_cyphertext + "\nDecrypted Cleartext: " + temp_cleartext);
}
}
</lsl>

== XTEA LSL <-> PHP ==
This is an XTEA implementation that has both LSL and PHP scripts to allow strong encryption not only inside LSL but also between LSL and a PHP serverscript.

For those who want to see this in action with your Web server try these. Be sure that if you edit these that Rounds and Key Phrase are the same in both LSL and PHP versions.

LSL - PLACE IN PRIM -- Edit to change URL and tosend text.

<lsl>

//************************************************//
//* Masa's XTEA encryption/decryption v3 *//
//* Modified by SleightOf Hand for Stability and *//
//* intercommunication with PHP version *//
//************************************************//
// NOTE: This version only encodes 60 bits per 64-bit block!
// This code is public domain.
// Sleight was here 20070522
// masa was here 20070315
// so was strife 20070315
// so was adz 20070812
//
// This was Modified by SleightOf Hand to allow
// Strong encryption between LSL and PHP.
//************************************************//
//* XTEA IMPLEMENTATION *//
//************************************************//

integer XTEA_DELTA = 0x9E3779B9; // (sqrt(5) - 1) * 2^31
integer xtea_num_rounds = 6;
list xtea_key = [0, 0, 0, 0];

// Converts any string to a 32 char MD5 string and then to a list of
// 4 * 32 bit integers = 128 bit Key. MD5 ensures always a specific
// 128 bit key is generated for any string passed.
list xtea_key_from_string( string str )
{
str = llMD5String(str,0); // Use Nonce = 0
return [ hexdec(llGetSubString( str, 0, 7)),
hexdec(llGetSubString( str, 8, 15)),
hexdec(llGetSubString( str, 16, 23)),
hexdec(llGetSubString( str, 24, 31))];
}

// Encipher two integers and return the result as a 12-byte string
// containing two base64-encoded integers.
string xtea_encipher( integer v0, integer v1 )
{
integer num_rounds = xtea_num_rounds;
integer sum = 0;
do {
// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.
v0 += (((v1 << 4) ^ ((v1 >> 5) & 0x07FFFFFF)) + v1) ^ (sum + llList2Integer(xtea_key, sum & 3));
sum += XTEA_DELTA;
v1 += (((v0 << 4) ^ ((v0 >> 5) & 0x07FFFFFF)) + v0) ^ (sum + llList2Integer(xtea_key, (sum >> 11) & 3));

} while( --num_rounds );
//return only first 6 chars to remove "=="'s and compact encrypted text.
return llGetSubString(llIntegerToBase64(v0),0,5) +
llGetSubString(llIntegerToBase64(v1),0,5);
}

// Decipher two base64-encoded integers and return the FIRST 30 BITS of
// each as one 10-byte base64-encoded string.
string xtea_decipher( integer v0, integer v1 )
{
integer num_rounds = xtea_num_rounds;
integer sum = XTEA_DELTA*xtea_num_rounds;
do {
// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.
v1 -= (((v0 << 4) ^ ((v0 >> 5) & 0x07FFFFFF)) + v0) ^ (sum + llList2Integer(xtea_key, (sum>>11) & 3));
sum -= XTEA_DELTA;
v0 -= (((v1 << 4) ^ ((v1 >> 5) & 0x07FFFFFF)) + v1) ^ (sum + llList2Integer(xtea_key, sum & 3));
} while ( --num_rounds );

return llGetSubString(llIntegerToBase64(v0), 0, 4) +
llGetSubString(llIntegerToBase64(v1), 0, 4);
}

// Encrypt a full string using XTEA.
string xtea_encrypt_string( string str )
{
// encode string
str = llStringToBase64(str);
// remove trailing =s so we can do our own 0 padding
integer i = llSubStringIndex( str, "=" );
if ( i != -1 )
str = llDeleteSubString( str, i, -1 );

// we don't want to process padding, so get length before adding it
integer len = llStringLength(str);

// zero pad
str += "AAAAAAAAAA=";

string result;
i = 0;

do {
// encipher 30 (5*6) bits at a time.
result += xtea_encipher(
llBase64ToInteger(llGetSubString(str, i, i += 4) + "A="),
llBase64ToInteger(llGetSubString(str, ++i, i += 4) + "A=")
);
} while ( ++i < len );

return result;
}

// Decrypt a full string using XTEA
string xtea_decrypt_string( string str ) {
integer len = llStringLength(str);
integer i;
string result;
do {
result += xtea_decipher(
llBase64ToInteger(llGetSubString(str, i, i += 5) + "=="),
llBase64ToInteger(llGetSubString(str, ++i, i += 5) + "==")
);
} while ( ++i < len );

// Replace multiple trailing zeroes with a single one
i = llStringLength(result) - 1;
while ( llGetSubString(result, --i, i+1) == "AA" )
result = llDeleteSubString(result, i+1, i+1);
return llBase64ToString( result + "====" );
}

key requestid; // just to check if we're getting the result we've asked for; all scripts in the same object get the same replies
string base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +

"abcdefghijklmnopqrstuvwxyz" +

"0123456789+/";
string url = "http://<enter your URL here>/test-script.php";

default
{
touch_start(integer number)
{
string tosend = "this is a message to send";
llWhisper(0, "Message to Send = " + tosend);
xtea_key = xtea_key_from_string("this is a test key");
string message = xtea_encrypt_string(tosend);
llWhisper(0, "Message to Server = " + message);
requestid = llHTTPRequest(url,
[HTTP_METHOD, "POST",
HTTP_MIMETYPE, "application/x-www-form-urlencoded"],
"parameter1=" + llEscapeURL(message));
}

http_response(key request_id, integer status, list metadata, string body)
{
if (request_id == requestid) {
llWhisper(0, "Web server sent: " + body);
integer clean = 0;
string cleanbody = "";
while(~llSubStringIndex(base64,llGetSubString(body,clean,clean))){
cleanbody += llGetSubString(body,clean,clean++);
}
llWhisper(0, "Cleaned : " + cleanbody);
llWhisper(0, "Web server said: " + xtea_decrypt_string( cleanbody ));
}
}
}

</lsl>

PHP Code - Place on web server at location that LSL URL will be looking for.

<php>
//************************************************//
//* Sleight's PHP XTEA encryption/decryption v3 *//
//* Modified by SleightOf Hand for Stability and *//
//* intercommunication between PHP & LSL *//
//************************************************//
// NOTE: This version only encodes 60 bits per 64-bit block!
// This code is public domain.
// Sleight was here 20070522
// masa was here 20070315
// so was strife 20070315
// so was adz 20080812
//
// This was converted from the LSL version by
// SleightOf Hand to allow Strong encryption
// between LSL and PHP. If you find this useful
// any donations appreciated.
//************************************************//
//* XTEA IMPLEMENTATION *//
//************************************************//

$_XTEA_DELTA = 0x9E3779B9; // (sqrt(5) - 1) * 2^31
$_xtea_num_rounds = 6;
$_xtea_key = array(0, 0, 0, 0);
$_base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
"abcdefghijklmnopqrstuvwxyz".
"0123456789+/";

// Returns Integer based on 8 byte Base64 Code XXXXXX== (llBase64ToInteger)
function base64_integer($str){
global $_base64;
if(strlen($str) != 8) return 0;
return ((strpos($_base64,$str{0}) << 26)|
(strpos($_base64,$str{1}) << 20)|
(strpos($_base64,$str{2}) << 14)|
(strpos($_base64,$str{3}) << 8) |
(strpos($_base64,$str{4}) << 2) |
(strpos($_base64,$str{5}) >> 4));
}

// Returns 8 Byte Base64 code based on 32 bit integer ((llIntegerToBase64)
function integer_base64($int){
global $_base64;
if($int != (integer) $int) return 0;
return $_base64{($int >> 26 & 0x3F)} .
$_base64{($int >> 20 & 0x3F)} .
$_base64{($int >> 14 & 0x3F)} .
$_base64{($int >> 8 & 0x3F)} .
$_base64{($int >> 2 & 0x3F)} .
$_base64{($int << 4 & 0x3F)} . "==";
}

//strict 32 bit addition using logic
function binadd($val1 , $val2){
$tc = $val1 & $val2;
$ta = $val1 ^ $val2;
do{
$tac = ($tc << 1) & 0x0FFFFFFFF;
$tc = $ta & $tac;
$ta = $ta ^ $tac;
}while($tc);
return $ta; // $ta will now be the result so return it
}

// Converts any string to a 32 char MD5 string and then to a list of
// 4 * 32 bit integers = 128 bit Key.
function xtea_key_from_string( $str ) {
global $_xtea_key;
$str = md5($str . ":0"); // Use nonce = 0 in LSL for same output
$_xtea_key[0] = hexdec(substr($str,0,8));
$_xtea_key[1] = hexdec(substr($str,8,8));
$_xtea_key[2] = hexdec(substr($str,16,8));
$_xtea_key[3] = hexdec(substr($str,24,8));
}

// Encipher two integers and return the result as a 12-byte string
// containing two base64-encoded integers.
function xtea_encipher( $v0 , $v1 ) {
global $_xtea_num_rounds , $_xtea_key , $_XTEA_DELTA;
$num_rounds = $_xtea_num_rounds;
$sum = 0;
do {
// LSL only has 32 bit integers. However PHP automatically changes
// 32 bit integers to 64 bit floats as necessary. This causes
// incompatibilities between the LSL Encryption and the PHP
// counterpart. I got round this by changing all addition to
// binary addition using logical & and ^ and loops to handle bit
// carries. This forces the 32 bit integer to remain 32 bits as
// I mask out any carry over 32 bits. this bring the output of the
// encrypt routine to conform with the output of its LSL counterpart.

// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.

// calculate ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
$v0a = binadd((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) , $v1);
// calculate ($sum + $_xtea_key[$sum & 3])
$v0b = binadd($sum , $_xtea_key[$sum & 3]);
// Calculate ($v0 + ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
// ^ ($sum + $_xtea_key[$sum & 3]))
$v0 = binadd($v0 , ($v0a ^ $v0b));

//Calculate ($sum + $_XTEA_DELTA)
$sum = binadd($sum , $_XTEA_DELTA);

//Calculate ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
$v1a = binadd((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) , $v0);
// Calculate ($sum + $_xtea_key[($sum >>11) & 3])
$v1b = binadd($sum , $_xtea_key[($sum >>11) & 3]);
//Calculate ($v1 + ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0
// ^ ($sum & $_xtea_key[($sum >>11) & 3]))
$v1 = binadd($v1 , ($v1a ^ $v1b));
} while( $num_rounds = ~-$num_rounds );
//return only first 6 chars to remove "=="'s and compact encrypted text.
return substr(integer_base64($v0),0,6) . substr(integer_base64($v1),0,6);
}

// Decipher two base64-encoded integers and return the FIRST 30 BITS of
// each as one 10-byte base64-encoded string.
function xtea_decipher( $v0, $v1 ) {
global $_xtea_num_rounds , $_xtea_key , $_XTEA_DELTA;
$num_rounds = $_xtea_num_rounds;
$sum = 0; // $_XTEA_DELTA * $_xtea_num_rounds;
$tda = $_XTEA_DELTA;
do{ // Binary multiplication using binary manipulation
if($num_rounds & 1){
$sum = binadd($sum , $tda);
}
$num_rounds = $num_rounds >> 1;
$tda = ($tda << 1) & 0x0FFFFFFFF;
}while($num_rounds);
$num_rounds = $_xtea_num_rounds; // reset $num_rounds back to its proper setting;

do {
// LSL only has 32 bit integers. However PHP automatically changes
// 32 bit integers to 64 bit floats as necessary. This causes
// incompatibilities between the LSL Encryption and the PHP
// counterpart. I got round this by changing all addition to
// binary addition using logical & and ^ and loops to handle bit
// carries. This forces the 32 bit integer to remain 32 bits as
// I mask out any carry over 32 bits. this bring the output of the
// decrypt routine to conform with the output of its LSL counterpart.
// Subtractions are handled by using 2's compliment

// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.

// calculate ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
$v1a = binadd((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) , $v0);
// calculate ($sum + $_xtea_key[($sum>>11) & 3])
$v1b = binadd($sum , $_xtea_key[($sum>>11) & 3]);
//Calculate 2's compliment of ($v1a ^ $v1b) for subtraction
$v1c = binadd((~($v1a ^ $v1b)) , 1);
//Calculate ($v1 - ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
// ^ ($sum + $_xtea_key[($sum>>11) & 3]))
$v1 = binadd($v1 , $v1c);

// Calculate new $sum based on $num_rounds - 1
$tnr = $num_rounds - 1; // Temp $num_rounds
$sum = 0; // $_XTEA_DELTA * ($num_rounds - 1);
$tda = $_XTEA_DELTA;
do{ // Binary multiplication using binary manipulation
if($tnr & 1){
$sum = binadd($sum , $tda);
}
$tnr = $tnr >> 1;
$tda = ($tda << 1) & 0x0FFFFFFFF;
}while($tnr);

//Calculate ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
$v0a = binadd((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) , $v1);
//Calculate ($sum + $_xtea_key[$sum & 3])
$v0b = binadd($sum , $_xtea_key[$sum & 3]);
//Calculate 2's compliment of ($v0a ^ $v0b) for subtraction
$v0c = binadd((~($v0a ^ $v0b)) , 1);
//Calculate ($v0 - ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1
// ^ ($sum + $_xtea_key[$sum & 3]))
$v0 = binadd($v0 , $v0c);
} while ( $num_rounds = ~-$num_rounds );

return substr(integer_base64($v0), 0, 5) . substr(integer_base64($v1), 0, 5);
}

// Encrypt a full string using XTEA.
function xtea_encrypt_string( $str ) {
// encode Binany string to Base64
$str = base64_encode($str);

// remove trailing =s so we can do our own 0 padding
$i = strpos($str, '=', 0);
if ( $i !== FALSE ){
$str = substr( $str, 0, $i);
}
// we don't want to process padding, so get length before adding it
$len = strlen($str);
// zero pad
$str .= "AAAAAAAAAA=";
$result = "";
$i = 0;

do {
// encipher 30 (5*6) bits at a time.
$enc1 = base64_integer(substr($str , $i , 5) . "A==");
$i += 5;
$enc2 = base64_integer(substr($str , $i , 5) . "A==");
$i += 5;
$result .= xtea_encipher($enc1, $enc2);
} while ( $i < $len );
return $result; //Return Encrypted string
}

// Decrypt a full string using XTEA
function xtea_decrypt_string( $str ) {
global $_base64 ;

$len = strlen($str);
$i;
$result;
do {
$dec1 = base64_integer(substr($str , $i , 6)."==");
$i += 6;
$dec2 = base64_integer(substr($str , $i , 6)."==");
$i += 6;
$result .= xtea_decipher( $dec1, $dec2);
} while ( $i < $len );

// Replace multiple trailing zeroes with a single one
$result = rtrim($result, "A");
$i = strlen($result);
$mod = $i%4; //Depending on encoded length different appends are needed
if($mod == 1) $result .= "A==";
else if($mod == 2 ) $result .= "==";
else if($mod == 3) $result .= "=";

return base64_decode( $result );
}

// Only works with PHP compiled as an Apache module
$headers = apache_request_headers();

$objectName = $headers["X-SecondLife-Object-Name"];
$objectKey = $headers["X-SecondLife-Object-Key"];
$ownerKey = $headers["X-SecondLife-Owner-Key"];
$ownerName = $headers["X-SecondLife-Owner-Name"];
$region = $headers["X-SecondLife-Region"];
// and so on for getting all the other variables ...

//to pull out this headers in other kinds of installations, use this (Adz)
/*
$objectName = $_SERVER['HTTP_X_SECONDLIFE_OBJECT_NAME'];
$objectKey = $_SERVER['HTTP_X_SECONDLIFE_OBJECT_KEY'];
$region = $_SERVER['HTTP_X_SECONDLIFE_REGION'];
$ownerName = $_SERVER['HTTP_X_SECONDLIFE_OWNER_NAME'];
$ownerKey = $_SERVER['HTTP_X_SECONDLIFE_OWNER_KEY'];
*/

xtea_key_from_string("this is a test key");
// get things from $_POST[]
// Naturally enough, if this is empty, you won't get anything
$parameter1 = xtea_decrypt_string($_POST["parameter1"]);

echo xtea_encrypt_string($ownerName . " just said " . $parameter1) . "\n";
</php>

This should result in the following output.

Object whispers: Message to Send = this is a message to send<br/>
Object whispers: Message to Server = JSdgCA0FDyhgLlUnSgqMQWkAxz1AzA1vr9zwSEDnCgwJ6GNQ<br />
Object whispers: Web server sent: SVbqNQ5XdkngeUI3bgP+s6eAT6GM4AWnYCYApcfxagrPbxmwiY7WXA4J+gEQ1AYhRQNvcnEwfZSo/AuKVtIw<br />
Object whispers: Cleaned : SVbqNQ5XdkngeUI3bgP+s6eAT6GM4AWnYCYApcfxagrPbxmwiY7WXA4J+gEQ1AYhRQNvcnEwfZSo/AuKVtIw<br />
Object whispers: Web server said: SleightOf Hand just said this is a message to send

PHP 5 class of XTEA

<php>
<?php
// http://wiki.secondlife.com/wiki/XTEA_Strong_Encryption_Implementation
//************************************************//
//* Sleight's PHP XTEA encryption/decryption v3 *//
//* Modified by SleightOf Hand for Stability and *//
//* intercommunication between PHP & LSL *//
//************************************************//
// NOTE: This version only encodes 60 bits per 64-bit block!
// This code is public domain.
// Sleight was here 20070522
// masa was here 20070315
// so was strife 20070315
// so was adz 20080812
// gave this some class 20080201 JB Kraft
//
// This was converted from the LSL version by
// SleightOf Hand to allow Strong encryption
// between LSL and PHP. If you find this usefull
// any donations apreciated.
//************************************************//
//* XTEA IMPLEMENTATION *//
//************************************************//

/**
* PHP 5 class to do XTEA crypting
*
* $xtea = new XTEA( "mypassword" );
* $crypted = $xtea->encrypt( "Some bogus string" );
* echo "Encrypted: " . bin2hex($crypted);
* echo "Decrypted: " . $xtea->decrypt( $crypted );
*
* @package whatevah
* @author JB Kraft
**/
class XTEA
{

private $_XTEA_DELTA = 0x9E3779B9; // (sqrt(5) - 1) * 2^31
private $_xtea_num_rounds = 6;
private $_xtea_key = array(0, 0, 0, 0);
private $_base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

/**
* CTOR
*
* @param $passwd the password to use for crypting
* @author JB Kraft
**/
public function __construct( $passwd )
{
$this->xtea_key_from_string( $passwd );
}

/**
* Encrypt a full string using XTEA.
*
* @param $str the string to encrypt
* @return the encrypted string
* @author JB Kraft
**/
public function encrypt( $str )
{
// encode Binany string to Base64
$str = base64_encode($str);

// remove trailing =s so we can do our own 0 padding
$i = strpos($str, '=', 0);
if ( $i !== FALSE ){
$str = substr( $str, 0, $i);
}
// we don't want to process padding, so get length before adding it
$len = strlen($str);
// zero pad
$str .= "AAAAAAAAAA=";
$result = "";
$i = 0;

do {
// encipher 30 (5*6) bits at a time.
$enc1 = $this->base64_integer(substr($str , $i , 5) . "A==");
$i += 5;
$enc2 = $this->base64_integer(substr($str , $i , 5) . "A==");
$i += 5;
$result .= $this->xtea_encipher($enc1, $enc2);
} while ( $i < $len );
return $result; //Return Encrypted string
}

/**
* Decrypt a full string using XTEA
*
* @param $str the string to decrypt
* @return the decrypted string
* @author JB Kraft
**/
public function decrypt( $str )
{
$len = strlen($str);
$i = 0;
$result = '';
do {
$dec1 = $this->base64_integer(substr($str , $i , 6)."==");
$i += 6;
$dec2 = $this->base64_integer(substr($str , $i , 6)."==");
$i += 6;
$result .= $this->xtea_decipher( $dec1, $dec2);
} while ( $i < $len );

// Replace multiple trailing zeroes with a single one
$i = strlen($result);
while ( substr($result, --$i, 1) == "A" );
$result = substr($result, 0, $i+1);
$i = strlen($result);
$mod = $i%4; //Depending on encoded length diffrent appends are needed
if($mod == 1) $result .= "A==";
else if($mod == 2 ) $result .= "==";
else if($mod == 3) $result .= "=";

return base64_decode( $result );
}

// -----------------------------
// stuff below here is protected
// -----------------------------

// Returns Integer based on 8 byte Base64 Code XXXXXX== (llBase64ToInteger)
protected function base64_integer($str)
{
if(strlen($str) != 8) return 0;
return ((strpos($this->_base64,$str{0}) << 26)|
(strpos($this->_base64,$str{1}) << 20)|
(strpos($this->_base64,$str{2}) << 14)|
(strpos($this->_base64,$str{3}) << 8) |
(strpos($this->_base64,$str{4}) << 2) |
(strpos($this->_base64,$str{5}) >> 4));
}

// Returns 8 Byte Base64 code based on 32 bit integer ((llIntegerToBase64)
protected function integer_base64($int)
{
if($int != (integer) $int) return 0;
return $this->_base64{($int >> 26 & 0x3F)} .
$this->_base64{($int >> 20 & 0x3F)} .
$this->_base64{($int >> 14 & 0x3F)} .
$this->_base64{($int >> 8 & 0x3F)} .
$this->_base64{($int >> 2 & 0x3F)} .
$this->_base64{($int << 4 & 0x3F)} . "==";
}

//strict 32 bit addition using logic
protected function binadd($val1 , $val2)
{
$tc = $val1 & $val2;
$ta = $val1 ^ $val2;
do{
$tac = ($tc << 1) & 0x0FFFFFFFF;
$tc = $ta & $tac;
$ta = $ta ^ $tac;
}while($tc);
return $ta; // $ta will now be the result so return it
}

// Convers any string to a 32 char MD5 string and then to a list of
// 4 * 32 bit integers = 128 bit Key.
protected function xtea_key_from_string( $str )
{
$str = md5($str . ":0"); // Use nonce = 0 in LSL for same output
$this->_xtea_key[0] = hexdec(substr($str,0,8));
$this->_xtea_key[1] = hexdec(substr($str,8,8));
$this->_xtea_key[2] = hexdec(substr($str,16,8));
$this->_xtea_key[3] = hexdec(substr($str,24,8));
}

// Encipher two integers and return the result as a 12-byte string
// containing two base64-encoded integers.
protected function xtea_encipher( $v0 , $v1 )
{
$num_rounds = $this->_xtea_num_rounds;
$sum = 0;
do {
// LSL only has 32 bit integers. However PHP automatically changes
// 32 bit integers to 64 bit floats as necessary. This causes
// incompatibilities between the LSL Encryption and the PHP
// counterpart. I got round this by changing all addition to
// binary addition using logical & and ^ and loops to handle bit
// carries. This forces the 32 bit integer to remain 32 bits as
// I mask out any carry over 32 bits. this bring the output of the
// encrypt routine to conform with the output of its LSL counterpart.

// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.

// calculate ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
$v0a = $this->binadd((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) , $v1);
// calculate ($sum + $this->_xtea_key[$sum & 3])
$v0b = $this->binadd($sum , $this->_xtea_key[$sum & 3]);
// Calculate ($v0 + ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
// ^ ($sum + $this->_xtea_key[$sum & 3]))
$v0 = $this->binadd($v0 , ($v0a ^ $v0b));

//Calculate ($sum + $this->_XTEA_DELTA)
$sum = $this->binadd($sum , $this->_XTEA_DELTA);

//Calculate ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
$v1a = $this->binadd((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) , $v0);
// Calculate ($sum + $this->_xtea_key[($sum >>11) & 3])
$v1b = $this->binadd($sum , $this->_xtea_key[($sum >>11) & 3]);
//Calculate ($v1 + ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0
// ^ ($sum & $this->_xtea_key[($sum >>11) & 3]))
$v1 = $this->binadd($v1 , ($v1a ^ $v1b));
} while( $num_rounds = ~-$num_rounds );
//return only first 6 chars to remove "=="'s and compact encrypted text.
return substr($this->integer_base64($v0),0,6) . substr($this->integer_base64($v1),0,6);
}

// Decipher two base64-encoded integers and return the FIRST 30 BITS of
// each as one 10-byte base64-encoded string.
protected function xtea_decipher( $v0, $v1 )
{
$num_rounds = $this->_xtea_num_rounds;
$sum = 0; // $this->_XTEA_DELTA * $this->_xtea_num_rounds;
$tda = $this->_XTEA_DELTA;
do{ // Binary multiplication using binary manipulation
if($num_rounds & 1){
$sum = $this->binadd($sum , $tda);
}
$num_rounds = $num_rounds >> 1;
$tda = ($tda << 1) & 0x0FFFFFFFF;
}while($num_rounds);
$num_rounds = $this->_xtea_num_rounds; // reset $num_rounds back to its propper setting;

do {
// LSL only has 32 bit integers. However PHP automatically changes
// 32 bit integers to 64 bit floats as necessary. This causes
// incompatibilities between the LSL Encryption and the PHP
// counterpart. I got round this by changing all addition to
// binary addition using logical & and ^ and loops to handle bit
// carries. This forces the 32 bit integer to remain 32 bits as
// I mask out any carry over 32 bits. this bring the output of the
// decrypt routine to conform with the output of its LSL counterpart.
// Subtractions are handled by using 2's compliment

// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.

// calculate ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
$v1a = $this->binadd((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) , $v0);
// calculate ($sum + $this->_xtea_key[($sum>>11) & 3])
$v1b = $this->binadd($sum , $this->_xtea_key[($sum>>11) & 3]);
//Calculate 2's compliment of ($v1a ^ $v1b) for subtraction
$v1c = $this->binadd((~($v1a ^ $v1b)) , 1);
//Calculate ($v1 - ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
// ^ ($sum + $this->_xtea_key[($sum>>11) & 3]))
$v1 = $this->binadd($v1 , $v1c);

// Calculate new $sum based on $num_rounds - 1
$tnr = $num_rounds - 1; // Temp $num_rounds
$sum = 0; // $this->_XTEA_DELTA * ($num_rounds - 1);
$tda = $this->_XTEA_DELTA;
do{ // Binary multiplication using binary manipulation
if($tnr & 1){
$sum = $this->binadd($sum , $tda);
}
$tnr = $tnr >> 1;
$tda = ($tda << 1) & 0x0FFFFFFFF;
}while($tnr);

//Calculate ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
$v0a = $this->binadd((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) , $v1);
//Calculate ($sum + $this->_xtea_key[$sum & 3])
$v0b = $this->binadd($sum , $this->_xtea_key[$sum & 3]);
//Calculate 2's compliment of ($v0a ^ $v0b) for subtraction
$v0c = $this->binadd((~($v0a ^ $v0b)) , 1);
//Calculate ($v0 - ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1
// ^ ($sum + $this->_xtea_key[$sum & 3]))
$v0 = $this->binadd($v0 , $v0c);
} while ( $num_rounds = ~-$num_rounds );

return substr($this->integer_base64($v0), 0, 5) . substr($this->integer_base64($v1), 0, 5);
}

}

?>
</php>

= Test Vectors =
These are test vectors to verify that the implementation is working correctly. Although the LSL implementation is for six rounds only, it can easily be changed to verify that the implementation is working as expected. Having a proper implementation allows other systems to communicate using the LSL implementation of XTEA.

==Bouncy Castle C# API==
These test vectors are taken from [http://www.bouncycastle.org/csharp/ The Bouncy Castle C# API].

{|{{Prettytable}}
|-{{Hl2}}
! Rounds
! Data
! Key
! Vector
|-
| 32
| {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}}
| {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}}
| {{LSL Hex|0xDEE9D4D8|}} {{LSL Hex|0xF7131ED9|}}

|-
| 32
| {{LSL Hex|0x01020304|}} {{LSL Hex|0x05060708|}}
| {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}}
| {{LSL Hex|0x065C1B89|}} {{LSL Hex|0x75C6A816|}}
|-
| 32
| {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}}
| {{LSL Hex|0x01234567|}} {{LSL Hex|0x12345678|}} {{LSL Hex|0x23456789|}} {{LSL Hex|0x3456789A|}}
| {{LSL Hex|0x1FF9A026|}} {{LSL Hex|0x1AC64264|}}
|-
| 32
| {{LSL Hex|0x01020304|}} {{LSL Hex|0x05060708|}}
| {{LSL Hex|0x01234567|}} {{LSL Hex|0x12345678|}} {{LSL Hex|0x23456789|}} {{LSL Hex|0x3456789A|}}
| {{LSL Hex|0x8C67155B|}} {{LSL Hex|0x2EF91EAD|}}
|}

==Test Vectors for TEA and XTEA==
These test vectors used are from [http://www.cix.co.uk/~klockstone/teavect.htm Test Vectors for TEA and XTEA].
They are made by starting with a vector of 6 zeroes, data followed by key, and coding with one cycle then moving the six cyclically so that n becomes n-1 modulo 6.

{|{{Prettytable}}
|-{{Hl2}}
! Round
!colspan="6"|vector
|-
| 1
||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x9E3779B9|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}
|-
| 2
||{{LSL Hex|0xEC01A1DE|}}||{{LSL Hex|0xAAA0256D|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}
|-
| 4
||{{LSL Hex|0xBC3A7DE2|}}||{{LSL Hex|0x4E238EB9|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0xEC01A1DE|}}||{{LSL Hex|0x114F6D74|}}
|-
| 8
||{{LSL Hex|0x31C5FA6C|}}||{{LSL Hex|0x241756D6|}}||{{LSL Hex|0xBC3A7DE2|}}||{{LSL Hex|0x845846CF|}}||{{LSL Hex|0x2794A127|}}||{{LSL Hex|0x6B8EA8B8|}}
|-
| 16
||{{LSL Hex|0x1D8E6992|}}||{{LSL Hex|0x9A478905|}}||{{LSL Hex|0x6A1D78C8|}}||{{LSL Hex|0x08C86D67|}}||{{LSL Hex|0x2A65BFBE|}}||{{LSL Hex|0xB4BD6E46|}}
|-
| 32
||{{LSL Hex|0xD26428AF|}}||{{LSL Hex|0x0A202283|}}||{{LSL Hex|0x27F917B1|}}||{{LSL Hex|0xC1DA8993|}}||{{LSL Hex|0x60E2ACAA|}}||{{LSL Hex|0xA6EB923D|}}
|-
| 64
||{{LSL Hex|0x7A01CBC9|}}||{{LSL Hex|0xB03D6068|}}||{{LSL Hex|0x62EE209F|}}||{{LSL Hex|0x069B7AFC|}}||{{LSL Hex|0x376A8936|}}||{{LSL Hex|0xCDC9E923|}}
|}

==LSL Test==
The following code has been imported to LSL to test the vectors with an XTEA implementation. It also makes use of a modified version of the [[Hex]] method on this wiki to display the data. Right Shift of signed integers is handed by techniques introduced in the [[Right_Shift]] method on this wiki.

<lsl>
// XTEA is a version of slightly improved TEA
// The plain or cypher text is in v[0], v[1]
// The key is in k[n], where n = 0 - 3
// The number of coding cycles is given by N and
// the number of decoding cycles is given by -N

list XTEA(list v, list k, integer N) // Replaces TEA's Code and Decode
{
integer y = llList2Integer(v, 0);
integer z = llList2Integer(v, 1);
integer DELTA = 0x9E3779B9;
integer limit = DELTA * N;
integer sum = 0;

if(N > 0) // encrypt
{
while(sum != limit)
{
y += (z << 4 ^ ((z >> 5) & 0x07FFFFFF)) + z ^ sum + llList2Integer(k, sum & 3);
sum += DELTA;
z += (y << 4 ^ ((y >> 5) & 0x07FFFFFF)) + y ^ sum + llList2Integer(k, (sum >> 11) & 3);
}
}
else // decrypt
{
for(sum = -limit; sum; )
{ z -= (y << 4 ^ ((y >> 5) & 0x07FFFFFF)) + y ^ sum + llList2Integer(k, (sum >> 11) & 3);
sum -= DELTA;
y -= (z << 4 ^ ((z >> 5) & 0x07FFFFFF)) + z ^ sum + llList2Integer(k, sum & 3);
}
}

return [y,z];
}
string hex(integer value)
{
string h = "";
while (value)
{
string c = llGetSubString("0123456789ABCDEF", value & 0xF, value & 0xF);
h = c + h;
value = (value >> 4) & 0x0FFFFFFF;
}
return "0x" + llGetSubString("00000000" + h, -8, -1);
}
default
{
state_entry()
{

// Bouncy Castle C# API Test Vectors
list v;
v = XTEA([0x00000000, 0x00000000], [0x00000000, 0x00000000, 0x00000000, 0x00000000], 32);
llSay(DEBUG_CHANNEL, hex(llList2Integer(v, 0)) + "\t" + hex(llList2Integer(v, 1)) + "\texpected\t0xDEE9D4D8\t0xF7131ED9");

v = XTEA([0x01020304, 0x05060708], [0x00000000, 0x00000000, 0x00000000, 0x00000000], 32);
llSay(DEBUG_CHANNEL, hex(llList2Integer(v, 0)) + "\t" + hex(llList2Integer(v, 1)) + "\texpected\t0x065C1B89\t0x75C6A816");

v = XTEA([0x00000000, 0x00000000], [0x01234567, 0x12345678, 0x23456789, 0x3456789A], 32);
llSay(DEBUG_CHANNEL, hex(llList2Integer(v, 0)) + "\t" + hex(llList2Integer(v, 1)) + "\texpected\t0x1FF9A026\t0x1AC64264");

v = XTEA([0x01020304, 0x05060708], [0x01234567, 0x12345678, 0x23456789, 0x3456789A], 32);
llSay(DEBUG_CHANNEL, hex(llList2Integer(v, 0)) + "\t" + hex(llList2Integer(v, 1)) + "\texpected\t0x8C67155B\t0x2EF91EAD");

// Test Vectors for XTEA

list pz = [0,0,0,0,0,0,0];
integer n;
for (n = 1; n < 65; n++)
{

list a = XTEA(llList2List(pz, n, n + 1), llList2List(pz, n + 2, n + 5), n);

pz = llListReplaceList(pz, a, n, n + 1);

if (n == (n & -n)) // if n power of 2
llSay(DEBUG_CHANNEL,
(string)n
+ "\t" + hex(llList2Integer(pz, n + 0))
+ "\t" + hex(llList2Integer(pz, n + 1))
+ "\t" + hex(llList2Integer(pz, n + 2))
+ "\t" + hex(llList2Integer(pz, n + 3))
+ "\t" + hex(llList2Integer(pz, n + 4))
+ "\t" + hex(llList2Integer(pz, n + 5))
);
pz = llListReplaceList(pz, llList2List(pz, n, n + 5), n + 6, n + 11);
}
}
}
</lsl>

{{#vardefine:sort|XTEA Strong Encryption Implementation}}{{LSLC|Library}}{{LSLC|Examples}}
[[Category:LSL Encryption]]

AES Java Implementation

2010-04-20T00:53:44Z

New Spore:

= Description =
The following is a simple Java example of AES encryption and decryption, compatible with the [[AES LSL Implementation|LSL AES Engine]] by [[User:Haravikk Mistral|Haravikk Mistral]].

= Required Classes =
== Base64Coder ==
<java>package lslAESCrypto;

/**
* A Base64 Encoder/Decoder.
* <p>
* This class is used to encode and decode data in Base64 format as described in
* RFC 1521.
* </p>
*/
public class Base64Coder {
/** Mapping table from 6-bits to Base64 characters. */
private static char[] BITS_TO_BASE64_CHAR =
{ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x',
'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+',
'/' };

/** Mapping table from Base64 characters to 6-bits. */
private static byte[] BASE64_CHAR_TO_BITS =
{ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1,
0, 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, -1, -1, -1, -1, -1, -1, 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, -1, -1, -1, -1, -1, };

/**
* Decodes a byte array from Base64 format. No blanks or line breaks are
* allowed within the Base64 encoded data.
*
* @param in
* a character array containing the Base64 encoded data.
* @return An array containing the decoded data bytes.
* @throws IllegalArgumentException
* if the input is not valid Base64 encoded data.
*/
public static byte[] decode(final char[] in)
throws IllegalArgumentException {
int len = in.length;
if (len % 4 != 0)
throw new IllegalArgumentException(
"Length of Base64 encoded input string is not a multiple of 4.");

// Ignore trailing equals
while (len > 0 && in[len - 1] == '=')
--len;

final byte[] bytes = new byte[(len * 3) / 4];
int o = 0;

for (int i = 0; i < len;) {
try {
final char c0 = in[i++];
final char c1 = in[i++];
final char c2 = (i < len) ? in[i++] : 'A';
final char c3 = (i < len) ? in[i++] : 'A';

if (c0 > 127 || c1 > 127 || c2 > 127 || c3 > 127)
throw new IllegalArgumentException(
"Invalid base64 character");

final byte b0 = Base64Coder.BASE64_CHAR_TO_BITS[c0];
final byte b1 = Base64Coder.BASE64_CHAR_TO_BITS[c1];
final byte b2 = Base64Coder.BASE64_CHAR_TO_BITS[c2];
final byte b3 = Base64Coder.BASE64_CHAR_TO_BITS[c3];

if (b0 < 0 || b1 < 0 || b2 < 0 || b3 < 0)
throw new IllegalArgumentException(
"Invalid base64 character");

bytes[o++] = (byte) ((b0 << 2) | (b1 >>> 4));
if (o < bytes.length) {
bytes[o++] = (byte) (((b1 & 0xF) << 4) | (b2 >>> 2));
if (o < bytes.length)
bytes[o++] = (byte) (((b2 & 0x3) << 6) | b3);
}
} catch (final ArrayIndexOutOfBoundsException e) {
throw new IllegalArgumentException("Invalid base64 character");
}
}

return bytes;
}

/**
* Decodes a byte array from Base64 format.
*
* @param s
* a Base64 String to be decoded.
* @return An array containing the decoded data bytes.
* @throws IllegalArgumentException
* if the input is not valid Base64 encoded data.
*/
public static byte[] decode(final String s) {
return Base64Coder.decode(s.toCharArray());
}

/**
* Decodes a string from Base64 format.
*
* @param s
* a Base64 String to be decoded.
* @return A String containing the decoded data.
* @throws IllegalArgumentException
* if the input is not valid Base64 encoded data.
*/
public static String decodeString(final String s) {
return new String(Base64Coder.decode(s));
}

/**
* Encodes a byte array into Base64 format. No blanks or line breaks are
* inserted.
*
* @param in
* an array containing the data bytes to be encoded.
* @return A character array with the Base64 encoded data.
*/
public static char[] encode(final byte[] in) {
return Base64Coder.encode(in, 0, in.length);
}

/**
* Encodes a byte array into Base64 format. No blanks or line breaks are
* inserted.
*
* @param in
* an array containing the data bytes to be encoded.
* @param offset
* the offset into the array at which to begin reading.
* @param bits
* number of <b>bits</b> to process from <code>in</code>.
* @return A character array with the Base64 encoded data.
*/
public static char[] encode(
final byte[] in,
final int offset,
final int bits) {
int length = bits / 8;
if ((length * 8) < bits) ++length;

final char[] chars = new char[((length + 2) / 3) * 4];
final int out = ((length * 4) + 2) / 3;

int mask = ~(-1 << (8 - (bits % 8))) | ~(-1 << (bits % 8));
if (mask == 0) mask = 0xFF;

int o = 0;
final int end = length + offset;
for (int i = offset; i < end;) {
final int b0 = ((i + 1) == end) ? in[i++] & mask : in[i++] & 0xFF;
final int b1 =
(i < length) ? (((i + 1) == end) ? in[i++] & mask
: in[i++] & 0xFF) : 0;
final int b2 =
(i < length) ? (((i + 1) == end) ? in[i++] & mask
: in[i++] & 0xFF) : 0;

final int i0 = (b0 >>> 2);
final int i1 = (((b0 & 0x3) << 4) | (b1 >>> 4));
final int i2 = (((b1 & 0xF) << 2) | (b2 >>> 6));
final int i3 = b2 & 0x3F;

chars[o++] = Base64Coder.BITS_TO_BASE64_CHAR[i0];
chars[o++] = Base64Coder.BITS_TO_BASE64_CHAR[i1];
chars[o] = (o < out) ? Base64Coder.BITS_TO_BASE64_CHAR[i2] : '=';
++o;
chars[o] = (o < out) ? Base64Coder.BITS_TO_BASE64_CHAR[i3] : '=';
++o;
}

return chars;
}

/**
* Produces a base64 string from the provided byte-array.
*
* @param bytes
* the byte-array to read-from.
* @return the base64 encoded string produced.
*/
public static String encodeString(final byte[] bytes) {
return Base64Coder.encodeString(bytes, 0, bytes.length);
}

/**
* Produces a base64 string from the provided byte-array slice.
*
* @param bytes
* the byte-array to read-from.
* @param offset
* the offset into the array at which to begin reading.
* @param bits
* number of <b>bits</b> to process from <code>bytes</code>.
* @return the base64 encoded string produced.
*/
public static String encodeString(
final byte[] bytes,
final int offset,
final int bits) {
return new String(Base64Coder.encode(bytes, offset, bits));
}

/**
* Encodes a string into Base64 format. No blanks or line breaks are
* inserted.
*
* @param s
* a String to be encoded.
* @return A String with the Base64 encoded data.
*/
public static String encodeString(final String s) {
return new String(Base64Coder.encode(s.getBytes()));
}

/** Dummy constructor. */
private Base64Coder() { /* Blocking constructor */}

}</java>

== HexCoder ==
<java>package lslAESCrypto;
/**
* The following is a simple set of static methods for converting from hex to
* bytes and vice-versa
*
* @author Haravikk Mistral
* @date Sep 15, 2008, 3:26:42 PM
* @version 1.0
*/
public class HexCoder {
/**
* Quick converts bytes to hex-characters
*
* @param bytes
* the byte-array to convert
* @return the hex-representation
*/
public static String bytesToHex(final byte[] bytes) {
final StringBuffer s = new StringBuffer(bytes.length * 2);
for (int i = 0; i < bytes.length; ++i) {
s.append(Character.forDigit((bytes[i] >> 4) & 0xF, 16));
s.append(Character.forDigit(bytes[i] & 0xF, 16));
}
return s.toString();
}

/**
* Quickly converts hex-characters to bytes
*
* @param s
* the hex-string
* @return the bytes represented
*/
public static byte[] hexToBytes(final String s) {
final byte[] bytes = new byte[s.length() / 2];
for (int i = 0; i < bytes.length; ++i)
bytes[i] = (byte) Integer.parseInt(
s.substring(2 * i, (2 * i) + 2),
16);
return bytes;
}
}
</java>

= Class =
<java>package lslAESCrypto;

import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Random;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
* <p>
* This is a class designed to process AES messages sent from the LSL
* implementation of AES which can be found here:<br/>
* <a
* href="https://wiki.secondlife.com/wiki/AES_LSL_Implementation">https://wiki
* .secondlife.com/wiki/AES_LSL_Implementation</a>
* </p>
* <p>
* This Java class will be updated to support the same modes of operation as the
* LSL implementation. It currently assumes that keys and input-vectors are
* processed as hex-strings, and that text is received as plain-text, while
* ciphertext will be handled as base64 strings.
* </p>
*
* @author Haravikk
* @date Sep 15, 2008, 4:18:48 PM
* @version 1.0
*/
public class LSLAESCrypto {
/** Our currently set block-cipher mode */
protected LSLAESCryptoMode mode = LSLAESCryptoMode.CBC;
/** Used to detect when a new {@link Cipher} Is needed. */
protected boolean modeChanged = false;

/** Our currently set padding mode */
protected LSLAESCryptoPad pad = LSLAESCryptoPad.NONE;
/** Our currently set pad-size */
protected int padSize = 512;

/** The currently loaded key */
protected SecretKeySpec keySpec = null;
/** The currently loaded input-vector */
protected IvParameterSpec ivSpec = null;

/** The currently active cipher */
protected Cipher cipher = null;

/** A random class for secure random operations. */
protected Random random = new SecureRandom();

/**
* Creates an instance of an LSL compatible AES handler.
*
* @param mode
* the cipher-block mode of operation
* @param pad
* the padding scheme to use
* @param padSize
* the block-size to use when padding. Must be a non-zero,
* positive value that is a multiple of 128.
* @param hexKey
* the key to start with (represented as hexadecimal string)
* @param hexIV
* the input vector to start with (represented as hexadecimal
* string)
* @throws NoSuchAlgorithmException
* if the AES algorithm is not supported by the current JVM
* @throws NoSuchPaddingException
* if the padding scheme chosen is not supported by the current
* JVM
*/
public LSLAESCrypto(
final LSLAESCryptoMode mode,
final LSLAESCryptoPad pad,
final int padSize,
final String hexKey,
final String hexIV)
throws NoSuchAlgorithmException,
NoSuchPaddingException {
this.init(mode, pad, padSize, hexKey, hexIV);
}

/**
* Decrypts a base64 ciphertext into plain-text
*
* @param base64ciphertext
* the ciphertext to decrypt
* @return the plain-text that was originally encrypted
* @throws InvalidKeyException
* if the currently loaded key is not valid
* @throws InvalidAlgorithmParameterException
* if the AES algorithm is not supported by the current JVM
* @throws IllegalBlockSizeException
* if the ciphertext is somehow unreadable (bad base64
* conversion)
* @throws BadPaddingException
* if the chosen mode of operation requires padded data
*/
public String decrypt(final String base64ciphertext)
throws InvalidKeyException,
InvalidAlgorithmParameterException,
IllegalBlockSizeException,
BadPaddingException {
if (this.modeChanged) try {
this.createCipher();
} catch (final Exception e) { /* Do nothing */}

this.cipher.init(Cipher.DECRYPT_MODE, this.keySpec, this.ivSpec);
return new String(this.cipher.doFinal(Base64Coder
.decode(base64ciphertext)));
}

/**
* Encrypts plain-text into a base64 string
*
* @param text
* the plain-text to encrypt
* @return the base64 ciphertext produced
* @throws IllegalBlockSizeException
* if the plain text is somehow invalid
* @throws BadPaddingException
* if the chosen mode of operation requires padded data
* @throws InvalidKeyException
* if the currently loaded key is invalid
* @throws InvalidAlgorithmParameterException
* if the AES algorithm is not supported by the current JVM
*/
public String encrypt(final String text)
throws IllegalBlockSizeException,
BadPaddingException,
InvalidKeyException,
InvalidAlgorithmParameterException {
if (this.modeChanged) try {
this.createCipher();
} catch (final Exception e) { /* Do nothing */}

this.cipher.init(Cipher.ENCRYPT_MODE, this.keySpec, this.ivSpec);

byte[] data = text.getBytes();
int bits = data.length * 8;

/* Apply padding */
LSLAESCryptoPad padding = this.pad;
if (padding == LSLAESCryptoPad.NONE) {
if (this.mode == LSLAESCryptoMode.CFB) { return Base64Coder
.encodeString(this.cipher.doFinal(data), 0, bits); }
padding = LSLAESCryptoPad.RBT;
}

int blockSize = this.padSize;
if (padding == LSLAESCryptoPad.RBT) blockSize = 128;

final int blocks = bits / blockSize;
int extra = bits % blockSize;

if (padding == LSLAESCryptoPad.RBT) {
if (extra > 0) {
/*
* This scheme takes the last encrypted block, encrypts it
* again, and XORs it with any leftover data, maintaining
* data-length. If input is less than a block in size, then the
* current input-vector is used.
*/
int bytes = extra / 8;
if ((bytes * 8) < extra) ++bytes;

// Grab leftover bytes
final byte[] t = new byte[bytes];
if (bytes > 0)
System.arraycopy(data, data.length - bytes, t, 0, bytes);

// Encrypt all other data.
byte[] lb;
if (blocks < 1) {
// If not enough for a block, double-encrypt IV.
data = new byte[0];
lb =
this.cipher.doFinal(this.cipher.doFinal(this.ivSpec
.getIV()));
} else {
// If there are blocks, then double-encrypt final one.
data = this.cipher.doFinal(data, 0, data.length - bytes);
lb = this.cipher.doFinal(data, data.length - 16, 16);
}

// XOR lb with t.
for (int i = 0; i < t.length; ++i)
t[i] ^= lb[i];

lb = new byte[data.length + t.length];
System.arraycopy(data, 0, lb, 0, data.length);
System.arraycopy(t, 0, lb, data.length, t.length);

return Base64Coder.encodeString(lb);
}
return Base64Coder.encodeString(this.cipher.doFinal(data), 0, bits);
}

// Padding schemes that add bytes until block-boundary is reached.
extra = blockSize - extra;

if (padding == LSLAESCryptoPad.NULLS_SAFE) {
++bits;
final int bytes = bits / 8;
final int bit = bytes % 8;

if (bytes < data.length) data[bytes] |= (1 << (8 - bit));
else {
final byte[] t = new byte[data.length + 1];
System.arraycopy(data, 0, t, 0, data.length);
t[data.length] = (byte) 0x80;
data = t;
}

if ((--extra) < 0) extra += blockSize;
padding = LSLAESCryptoPad.NULLS;
}

int bytes = extra / 8;
if (bytes <= 0) {
if (padding == LSLAESCryptoPad.NULLS)
return Base64Coder.encodeString(
this.cipher.doFinal(data),
0,
bits);

bytes = blockSize / 8;
extra += blockSize;
}

bits += extra;
final byte[] t = new byte[data.length + bytes];
int i = data.length;
System.arraycopy(data, 0, t, 0, data.length);
data = t;

for (; i < data.length; ++i) {
byte b = 0;
if ((i >= (data.length - 4)) && (padding != LSLAESCryptoPad.NULLS)) b =
(byte) bytes;
else if (padding == LSLAESCryptoPad.RANDOM)
b = (byte) this.random.nextInt(256);

data[i] = b;
}

return Base64Coder.encodeString(this.cipher.doFinal(data), 0, bits);
}

/**
* Initialises this AES instance with a mode, pad, key, and input vector in
* a single operation
*
* @param mode
* the cipher-block mode of operation
* @param pad
* the padding scheme to use
* @param padSize
* the block-size to use when padding. Must be a non-zero,
* positive value that is a multiple of 128.
* @param hexKey
* the key to use as a hexadecimal string
* @param hexIV
* the input-vector to use as a hexadecimal string
* @throws NoSuchAlgorithmException
* if the AES algorithm is not supported by the current JVM
* @throws NoSuchPaddingException
* if the padding method is not supported by the current JVM
*/
public void init(
final LSLAESCryptoMode mode,
final LSLAESCryptoPad pad,
final int padSize,
final String hexKey,
final String hexIV)
throws NoSuchAlgorithmException,
NoSuchPaddingException {
if ((mode == null) || (pad == null) || (hexKey == null) ||
(hexIV == null))
throw new IllegalArgumentException("No arguments may be null");

this.setMode(mode);
this.setPad(pad, padSize);
this.setKey(hexKey);
this.setInputVector(hexIV);

this.random.nextInt();

this.createCipher();
}

/**
* Sets the input-vector for this engine to use
*
* @param hexIV
* a hexadecimal input-vector to use
*/
public void setInputVector(final String hexIV) {
if (hexIV == null)
throw new IllegalArgumentException("Input-vector may not be null!");

this.ivSpec = new IvParameterSpec(HexCoder.hexToBytes(hexIV));
}

/**
* Sets the key for this engine to use
*
* @param hexKey
* a hexadecimal key to use
*/
public void setKey(final String hexKey) {
if (hexKey == null)
throw new IllegalArgumentException("Key may not be null!");

this.keySpec = new SecretKeySpec(HexCoder.hexToBytes(hexKey), "AES");
}

/**
* Sets the mode of this implementation
*
* @param mode
* the mode to set
*/
public void setMode(final LSLAESCryptoMode mode) {
if (mode == null)
throw new IllegalArgumentException("Mode may not be null!");

this.mode = mode;
this.modeChanged = true;
}

/**
* Sets the padding scheme of this implementation
*
* @param pad
* the padding scheme to use
*/
public void setPad(final LSLAESCryptoPad pad) {
this.setPad(pad, this.padSize);
}

/**
* Sets the padding scheme of this implementation
*
* @param pad
* the padding scheme to use
* @param padSize
* the block-size to use when padding. Must be a non-zero,
* positive value that is a multiple of 128.
*/
public void setPad(final LSLAESCryptoPad pad, final int padSize) {
if (pad == null)
throw new IllegalArgumentException("Pad may not be null!");
if ((padSize <= 0) || ((padSize % 128) > 0))
throw new IllegalArgumentException(
"Pad size may not be less than zero, and must be a multiple of 128");

this.pad = pad;
this.padSize = padSize;
}

/**
* Creates a new cipher instance for processing
*
* @throws NoSuchPaddingException
* if the padding scheme set is invalid
* @throws NoSuchAlgorithmException
* if AES is not supported by this JVM
*/
protected void createCipher()
throws NoSuchAlgorithmException,
NoSuchPaddingException {
this.cipher = Cipher.getInstance("AES/" + this.mode + "/NoPadding");
}

/** Defines modes of operation combatible with LSL */
public enum LSLAESCryptoMode {
/** Cipher-Block-Chaining mode */
CBC,
/** Cipher FeedBack mode */
CFB;
}

/** Defines padding schemes compatible with LSL */
public enum LSLAESCryptoPad {
/** Performs no padding, will switch to RBT if mode is CBC. */
NONE,
/**
* Enables CFB mode temporarily for the final complete block, and
* combines with data. This preserves data-length.
*/
RBT,
/**
* Adds null-bytes to the end of the data until it is of correct-size.
* This is an padding scheme (may result in loss of null-bytes from
* original data).
*/
NULLS,
/**
* Same as NULLS, except that it first appends a single '1' bit to the
* data before padding.
*/
NULLS_SAFE,
/**
* Appends null-bytes to the data until one word from block-size, final
* word is then populated with bytes describing the number of padding
* bytes added.
*/
ZEROES,
/**
* Same as ZEROES, except that random-bytes are used in place of
* null-bytes.
*/
RANDOM;
}
}</java>

= Examples =
== Encryption ==
<java>import lslAESCrypto.LSLAESCrypto;
import lslAESCrypto.LSLAESCrypto.LSLAESCryptoMode;
import lslAESCrypto.LSLAESCrypto.LSLAESCryptoPad;

/** */
public class ExampleEncrypt {
/**
* @param args
* @throws Exception
*/
public static void main(final String[] args) throws Exception {
final String myKey = "1234567890ABCDEF0123456789ABCDEF";
final String myIV = "89ABCDEF0123456789ABCDEF01234567";
final String myMsg = "Hello world! I am a lovely message waiting to be encrypted!";

final LSLAESCrypto aes = new LSLAESCrypto(
LSLAESCryptoMode.CFB,
LSLAESCryptoPad.NoPadding,
myKey,
myIV);
System.out.println(aes.encrypt(myMsg));
}
}</java>

== Decryption ==
<java>import lslAESCrypto.LSLAESCrypto;
import lslAESCrypto.LSLAESCrypto.LSLAESCryptoMode;
import lslAESCrypto.LSLAESCrypto.LSLAESCryptoPad;

/** */
public class ExampleDecrypt {
/**
* @param args
* @throws Exception
*/
public static void main(final String[] args) throws Exception {
final String myKey = "1234567890ABCDEF0123456789ABCDEF";
final String myIV = "89ABCDEF0123456789ABCDEF01234567";
final String myMsg = "Mdn6jGTwRPMOKTYTTdDKGm9KScz26LIz96KVOGAeMw3hpwByPfa07PDRHxRW4TIh5dmu5LlhKpTQChi=";

final LSLAESCrypto aes = new LSLAESCrypto(
LSLAESCryptoMode.CFB,
LSLAESCryptoPad.NoPadding,
myKey,
myIV);
System.out.println(aes.decrypt(myMsg));
}
}</java>

PyOGP Client Library

2010-04-10T01:40:25Z

New Spore:

{{PyOGP/navigation}}
== Intro ==

PyOGP is a young, open source, python client library which provides an interface to an agent (client) of a Second Life grid. The code aims to enable automated testing of Second Life grids, to encourage and enable exploration into the client/server relationship and related protocols of Second Life, and to make possible simple prototyping of various client applications.

Hosted on svn.secondlife.com, it does require a contributor's agreement for commit access, and currently has a few contributors from the Second Life open source community.

P.S. We'll likely be moving to hg relatively soon...

* mailing list: pyogp@lists.secondlife.com
* irc: irc://irc.freenode.com/#pyogp
* wiki: http://wiki.secondlife.com/wiki/Pyogp
* licensing: Apache 2.0 license, copyright Linden Lab

=== Goals ===

In the very near future, we can have tests available to be run as soon as a deploy is completed that exercise a simulator/grid in the same way we do a smoke test. We will use these as automated tests run at build time, post deploy validation, and regression testing of simulators and backend systems.

This provides early feedback on code quality. QA is then able to dive deeper in testing the changes specific to a branch.

Having this library available also allows us to test potential changes before we have finalized design and are ready to submit to QA. Not sure how something will play out? Try it, and test it with PyOGP....

=== A Brief History ===

PyOGP was originally created as a tool for testing [[OGP]] related changes to the Second Life grid. By the end of the summer in 2008, the '''pyogp.lib.base''' package provided a skeleton messaging system and was able to test Linden Lab's first implementation of an agent domain and the related changes in an agent's region handoff and teleport. As the development effort around OGP waned, we started to extend pyogp by adding higher level client related functionality. Recently, this functionality was split out into a separate python package ('''pyogp.lib.client'''), and sample scripts (and future apps) were moved into '''pyogp.apps'''.

== Architecture Overview==

=== Structure ===

PyOGP is comprised of three python packages. The library consists of pyogp.lib.base and pyogp.lib.client, while sample scripts, and in time applications, live in pyogp.apps.
:'''pyogp.lib.base''' - consists of basic networking, messaging systems (UDP and event queue) and capabilities, custom datatypes, and a low level message related event system
:'''pyogp.lib.client''' - consists of 'convenience' classes mapping methods and handlers to specific messages (e.g. Agent().say(msg) tells the client to send the ChatFromViewer message to the host region). Raises application oriented events based on processing of messages (these are currently sparsely implemented)
:'''pyogp.apps''' - sample scripts and works in progress, the scripts here generally illustrate simple usage of classes as related to in world interactions by an agent of a Second Life grid

=== Dependencies ===

==== Platform / Python version compatibility ====

PyOGP aims to be compatible across platforms, though there are known problems with various environments. We'll be focusing on ensuring better compatibility soon.

'''Known good configurations'''

:Windows XP + Python 2.5
:Mac + Python 2.5, 2.6
:Linux + Python 2.4, 2.5, 2.6 (Linden hosts fall into this group)

'''Known bad configurations'''
:Windows Vista + Python 2.6
:Windows 7 + Python 2.6

There have been challenges in ensuring compatibility between the various dependencies, largely due to greenlet, eventlet, and pyopenssl. Please report bugs on [http://jira.secondlife.com/browse/PYO pJira]

==== Python module dependencies ====

The packages that make up PyOGP have some dependencies on python modules not included in a standard install, or sometimes not available on an older Python distribution.

'''pyogp.lib.base dependencies:'''

<python> #from setup.py

install_requires=[
'setuptools',
# -*- Extra requirements: -*-
'uuid',
'elementtree',
'llbase',
'WebOb',
'wsgiref',
'eventlet==0.8.14'
]</python>

'''pyogp.lib.client dependencies:'''

<python> install_requires=[
'setuptools',
# -*- Extra requirements: -*-
'pyogp.lib.base'
] </python>

'''pyogp.apps dependencies:'''

<python> install_requires=[
'setuptools',
'pyogp.lib.client'
]</python>

=== How to install ===

''Lindens can see internal documentation for more specific guidance. https://wiki.lindenlab.com/wiki/Pyogp#How_to_Install''

==== Standalone dev environment using buildout ====

Buildout is a type of Python development environment, organizing and configuring various components and their dependencies. On a desktop, one may checkout such an environment for working with PyOGP. One may optionally use a virtualenv Python environment to isolate the development code and it's runtime environment on one's host.

Dependencies: buildout takes care of everything, grabbing needed modules etc.

Wiki instructions: https://wiki.secondlife.com/wiki/Pyogp/Client_Lib/The_Development_Sandbox

==== Installing the PyOGP packages ====

Each of the PyOGP package may be installed to one's Python install or to a [http://pypi.python.org/pypi/virtualenv virtualenv]. '''Buyer beware''' if installing into your system's install: you'll want to be able to uninstall manually, as we haven't hooked up the uninstall. PyOGP is still coming up to speed with respect to distutils and pypi and the like, but it's relatively close now.

To install a package, simply run 'python setup.py install' in a package's root.

==== Referencing PyOGP packages via the PATH ====

Source code can be referenced directly if one simply ensures that a package, and it's dependencies, are available in the PYTHONPATH environmental variable.

== Current functional coverage ==

Anything not listed as covered is probably not yet covered.

pyogp.lib.base:
:* base udp messaging system (message.*)
:** UDP serialization/deserialization
:** message_template.msg parsing
:* base event queue messaging system (event_queue.EventQueueClient())
:* capabilities and their methods. Seed capabilities are a special case. (caps.Capability())
:* Message-based events (message.message_handler)

pyogp.lib.client:
:* agents (agent.Agent())
:** L$ balance request, friending, and walk/fly/sit/stand actions...
:* OGP agentdomain (agentdomain.AgentDomain())
:* application level events (event_system.AppEventsHandler())
:* some object handling (objects.*)
:** edit name, description, next-owner permissions and more
:** object creation is possible
:* some inventory handling (inventory.*)
:** login inv skeletons
:** fetching inventory, including AIS (caps based Agent Inventory Services))
:** some creating of new inventory items (LSL scripts, notecards)
:* regions (region.Region())
:** host and neighboring regions are handled slightly differently
:** udp and event queue connections are optionally enabled for each case
:** currently only pulling caps available to the agent via the seed cap (plus using the inventory related caps in the AIS context)
:* some appearance handling (appearance.AppearanceManager),
:* parcels
:* chat
:* some ImprovedInstantMessage handling
:** raises events on received instant messages
:** can deal with inventory offers/accepts/declines
:** other cases in this message are currently only logged
:* groups
:* group chat
:* LSL script uploading

=== Sample Scripts ===

There are a variety of scripted examples that have been used to exercise and test functionality as it is added to the library. These persist as coded documentation.

The source code is available in https://svn.secondlife.com/svn/linden/projects/2008/pyogp/pyogp.apps/trunk/pyogp/apps/examples/.

The following refers to a buildout context. If one installs pyogp.apps vi setup.py, these scripts will exist in the python environment's bin/ directory. In the buildout context, these scripts are available in {buildout root}/bin.

The scripts are derived from a package's 'setup.py' via the entry_points parameter, and essentially build executable Python scripts configured to run in the correct environment with the proper dependencies added the the path used by the script. These scripts are currently just simple illustrations of some uses of the PyOGP codebase.

<python> #the current entry_points in setup.py og pyogp.apps:

entry_points={
'console_scripts': [
'AIS_inventory_handling = pyogp.apps.examples.AIS_inventory_handling:main',
'agent_login = pyogp.apps.examples.agent_login:main',
'agent_manager = pyogp.apps.examples.agent_manager:main',
'appearance_management = pyogp.apps.examples.appearance_management:main',
'chat_and_instant_messaging = pyogp.apps.examples.chat_and_instant_messaging:main',
'group_chat = pyogp.apps.examples.group_chat:main',
'group_creation = pyogp.apps.examples.group_creation:main',
'inventory_handling = pyogp.apps.examples.inventory_handling:main',
'inventory_transfer = pyogp.apps.examples.inventory_transfer:main',
'inventory_transfer_specify_agent = pyogp.apps.examples.inventory_transfer_specify_agent:main',
'login = pyogp.apps.examples.login:main',
'multi_region_connect = pyogp.apps.examples.multi_region_connect:main',
'object_create_edit = pyogp.apps.examples.object_create_edit:main',
'object_create_permissions = pyogp.apps.examples.object_create_permissions:main',
'object_create_rez_script = pyogp.apps.examples.object_create_rez_script:main',
'object_creation = pyogp.apps.examples.object_creation:main',
'object_properties = pyogp.apps.examples.object_properties:main',
'object_tracking = pyogp.apps.examples.object_tracking:main',
'parcel_management = pyogp.apps.examples.parcel_management:main',
'parse_packets = pyogp.apps.examples.parse_packets:main',
'region_connect = pyogp.apps.examples.region_connect:main',
'smoke_test = pyogp.apps.examples.smoke_test:main',
'chat = pyogp.apps.examples.chat_interface:main',
]
}</python>

== How it Works (High Level) ==

=== Eventlet ===

PyOGP use [[Eventlet]] to run coroutines to handle multiple 'concurrent' processes, rather than threads or multiple processes. Each client agent instance will spawn a handful of coroutines to handles e.g. the UDP pipe, the Event Queue, various monitors, while yielding time to the parent process which should ensure it yields to the other routines as well.

PyOGP uses eventlet in very elementary ways at this point, but will perhaps start to use blocking queues in some cases, so that the coroutine only is allocated processing time if there is work for it to do.

=== pyogp.lib.base ===

This package handles the protocols used when communicating with a Second Life grid. A high level perspective on the package reveals a MessageManager() (still in development) which provides an interface to the UDP and Event Queue connections, as well as basic networking with enables login and capabilities interactions. The base package also has a low level even system through which all messages are passed and sent to subscribers.

Any subcomponent is available for direct interaction at any time, the MessageManager() and the MessageHandler() are the simple access points.

==== Events & Callbacks ====

The event implementation in pyogp follows the observer pattern, where observers subscribe to and are notified when an event occurs. Data is passed throughout the client instance via events.

* MessageManager - is an attribute of a Region and every packet received/sent is filtered through here. subscriptions are by message name
** MessageHandler - is an attribute of MessageManager, and every categorized message received from the event queue or udp dispatcher is filtered through here. (message as defined in message_template.msg, or one of ['ChatterBoxInvitation', 'ChatterBoxSessionEventReply', 'ChatterBoxSessionAgentListUpdates', 'ChatterBoxSessionStartReply', 'EstablishAgentCommunication']. There may be unhandled messages, I just haven't seen em yet :))

===== Message Events =====

In the most fundamental implementation of event usage, all packets are passed through a MessageManager() instance for evaluation. Observers may register to receive udp packets serialized into the form of Message() instances. The MessageHandler() is a consolidation point for subscribing to messages keyed by message name, and created on demand via subscription.

See pyogp.lib.base.message.message_handler.MessageHandler() for more details.

The pyogp agent's Region() instances each monitor their stream of packets (e.g. the host region: agent.region.message_manager.message_handler). (Perhaps this should be changed to a generalized Network() class where all packets (coupled to their originating regions) are evaluated.

Event firing passes data on to a callback handler defined in the subscription, in the form of (handler, *args, **kwargs).

The Agent class monitors the ImprovedInstantMessage packet:
<python> onImprovedInstantMessage_received = self.region.message_handler.register('ImprovedInstantMessage')
onImprovedInstantMessage_received.subscribe(self.onImprovedInstantMessage)

def onImprovedInstantMessage(self, packet):
""" handles the many cases of data being passed in this message """

{code} # parse and handle the data...</python>

The messaging system then fires the event when an ImprovedInstantMessage message is received, which calls onImprovedInstantMessage method above to handle the message contents. Multiple subscribers may be listening for any message related event, and each would be notified of the same Message() instance.

Unsubscribing from an event:
<python> onImprovedInstantMessage_received.unsubscribe(self.onImprovedInstantMessage)</python>

There are various event and callback implementations viewable in pyogp, poke around and help consolidate things if you like.

=== pyogp.lib.client ===

The client package generally provides a convenient interface to initiate or interpret interactions with host region (or neighboring regions). By listening to the messaging related event system in pyogp.lib.base, the client package interprets the messages that come in off the wire, and executes business logic in building responses. pyogp.lib.client also provides simple methods to enable the ending of messages to a grid.

==== Events ====

* EventsHandler - an attribute of an Agent, also able to be passed in, that is intended as the primary interface of a pyogp application into the internal state and data events within the lib. This system uses the same base classes as used by the MessageHandler() in the base package, and the descriptions about events and callbacks above apply here as well. The api for subscribing to these events is similar to the MessageHandler(), with an additional timeout parameter passed in the _register() method. When the specified timeout expires, the subscription returns None and expires the subscription.

==== Agent Login (examples) ====

===== Single Agent Login & Chat=====

Spawn a client in a co-routine, allowing persistent presence until forcefully terminated.

<python>from eventlet import api

from pyogp.lib.client.agent import Agent
from pyogp.lib.client.settings import Settings

settings = Settings()

settings.ENABLE_INVENTORY_MANAGEMENT = True
settings.MULTIPLE_SIM_CONNECTIONS = False

client = Agent(settings = settings)

api.spawn(client.login, options.loginuri, 'first', 'last', 'password', start_location = options.region)

# wait for the agent to connect to it's region
while client.connected == False:
api.sleep(0)

while client.region.connected == False:
api.sleep(0)

client.say("Hello World!")

# once connected, live until someone kills me
while client.running:
api.sleep(0)</python>

===== Multiple Agent Login =====

Each agent instance in logged in in a separate coroutine.

<python>from pyogp.lib.client.agent import Agent
from pyogp.lib.client.agentmanager import AgentManager

credentials= [('agent1', 'lastname', 'password'), ('agent2', 'lastname', 'password')]

# prime the Agent instances
agents = [Agent(settings, firstname, lastname, password)
for firstname, lastname, password in credentials]

agentmanager = AgentManager()
agentmanager.initialize(agents)

# log them in
for key in agentmanager.agents:
agentmanager.login(key, options.loginuri, options.region)

# while they are connected, stay alive
while agentmanager.has_agents_running():
api.sleep(0)</python>

== Extending Functionality ==

While the implementations and structures in pyogp.lib.base can (and are in the process of) being refactored to improve performance or usability, it is a fairly complete package.

The functional coverage PyOGP provides on the other hand is not complete, and there are a variety of needs to complete the implementation in pyogp.lib.base. We need to improve coverage of message handling (dealing with messages sent to the client), add more wrappers for sending various messages and performing multistep tasks (to simplify the initiation of interactions with the region), and we need to raise more application level events in the client package so that applications have easy access to incoming data.

=== Sending Messages ===

PyOGP, like the Viewer, communicates with the Second Life simulator by sending messages over UDP.

In order to extend PyOGP, you'll build a representation of a new UDP message, and send it through the pyogp.lib.base modules for serialization and wire handling.

=== Example: Sending an IM ===

To send an IM to the simulator, send an ImprovedInstantMessage packet. The base class for message packets is defined in <code>base/message/message.py</code>

Packets are assembled using a Message() instance which has the message name and Block() instances passed in through its constructor. Similarly, Blocks are assembled by passing in the Block name and the value name and values for each of the Block values. (The ability to build Message() instances via an llsd payload is expected to be introduced soon.)

Note: It is important that the message name, block name, and value names and types should match what is specified in the message template. (It is also possible to manipulate the representation of the stored template, or to use a custom message template.)

Example:
<python> def send_ImprovedInstantMessage(self, AgentID = None, SessionID = None,
FromGroup = None, ToAgentID = None,
ParentEstateID = None, RegionID = None,
Position = None, Offline = None,
Dialog = None, _ID = None, Timestamp = None,
FromAgentName = None, _Message = None,
BinaryBucket = None):
"""
sends an instant message packet to ToAgentID. this is a
multi-purpose message for inventory offer handling, im, group chat,
and more
"""

packet = Message('ImprovedInstantMessage',
Block('AgentData',
AgentID = AgentID,
SessionID = SessionID),
Block('MessageBlock',
FromGroup = FromGroup,
ToAgentID = ToAgentID,
ParentEstateID = ParentEstateID,
RegionID = RegionID,
Position = Position,
Offline = Offline,
Dialog = Dialog,
ID = UUID(str(_ID)),
Timestamp = Timestamp,
FromAgentName = FromAgentName,
Message = _Message,
BinaryBucket = BinaryBucket))

# Send the message:
self.region.enqueue_message(packet, True)</python>

=== Handling Incoming Messages and Raising an Event ===

To listen for when messages of a particular type are sent to the client instance, subscribe to the MessageHandler() on the host region's MessageManager(), like the example that follows:

<python> onImprovedInstantMessage_received = self.region.message_handler.register('ImprovedInstantMessage')
onImprovedInstantMessage_received.subscribe(self.onImprovedInstantMessage)</python>

When the event is fired upon receipt of the message matching the name, the specified callback handles the data passed along, and in this case raises an event notifying observers of the 'InstantMessageReceived' event in pyogp.lib.client of the important data.

<python> def onImprovedInstantMessage(self, packet):
""" callback handler for received ImprovedInstantMessage messages. much is passed in this message, and handling the data is only partially implemented """

Dialog = packet.blocks['MessageBlock'][0].get_variable('Dialog').data
FromAgentID = packet.blocks['AgentData'][0].get_variable('AgentID').data

if Dialog == ImprovedIMDialogue.InventoryOffered:

self.inventory.handle_inventory_offer(packet)

# ...
# some of the Dialogue types this message can contain are handled, we are showing 2
# ...

elif Dialog == ImprovedIMDialogue.FromAgent:

# ... code parses the data from the Message() instance ...

message = AppEvent('InstantMessageReceived', FromAgentID = FromAgentID, RegionID = RegionID, Position = Position, ID = ID, FromAgentName = FromAgentName, Message = _Message)

logger.info("Received instant message from %s: %s" % (FromAgentName, _Message))

self.events_handler.handle(message)</python>

== Logging ==

Uses python's standard logging module (http://docs.python.org/library/logging.html). The library defines logging events throughout, it is up to the application/script to determine the output.

Hooking logging into a new module:

<python>from logging import getLogger

# initialize logging
logger = getLogger('pyogp.lib.client.agent')

class Agent(object):
""" our agent class """

def __init__(self, params):

self.params = params

logger.debug("Initializing agent with params: %s" % (params))</python>

An application can then set up the logging output as follows (or any other way it pleases):

<python>console = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)-30s%(name)-30s: %(levelname)-8s %(message)s')
console.setFormatter(formatter)
logging.getLogger('').addHandler(console)
logging.getLogger('').setLevel(logging.DEBUG)</python>

The output to console is then:

<bash>2009-04-21 22:08:58,681 pyogp.lib.base.agent : DEBUG agent with params: params</bash>

== Pyogp Unit Tests ==

See [[PyOGP_Package_Unittests]].

== Sphinx (api docs) ==

'''Api documentation is now available for PyOGP packages''' (well, not for apps yet, but someday....)!

In pyogp/docs in each of the pyogp.lib.base and pyogp.lib.client packages, one will find source, last revision, and build files for sphinx based documents. Output is available at {package root}/docs/html/index.html.

We plan on sharing the api documentation on the web soon, and will work to make simple build wrappers work on various platforms, though this is a low priority.

Ask Enus for updated documentation to be checked in, or, build a better refresh.py.

== Roadmap ==

See [[Pyogp/Roadmap]] for details, or ask in irc or on the mailing list. Here's what's up in the near term for pyogp:

* better '''packaging''' and '''platform compatibility'''
* more '''functional coverage''' of message. We are covering 32% of the messages the viewers sends or handles when received (though it's estimated at more like 50% of normal use cases.
* '''permissions system testing''' to save QA from 3-5 day regression passes on perms
* '''appearance''' - this will require enabling upload and download, plus baking. Anyone have some spare time? :)

[[Category: Pyogp_Client_Lib]]
[[Category: Pyogp]]
[[Category:Architecture Working Group]]
[[Category:Grid_Interoperability]]
[[Category:AW Groupies]]
[[Category:MMOX]]

XTEA Strong Encryption Implementation

2010-03-12T06:52:19Z

New Spore:

{{LSL Header}}{{RightToc}}

XTEA Strong Encryption Implementation - Linden Scripting Language (LSL)
Version 1.0

= Contributors =
*[http://morsedillon.com/ Morse Dillon], Author, (morseATmorsedillon.com)
*{{User|Strife Onizuka}} (blindwandererATgmail.com)
*[http://dedricmauriac.wordpress.com/ Dedric Mauriac], Contributor (dedric.mauriacATgmail.com)
*{{User|JB_Kraft}} (php 5 class)

= License =
This work is licensed under a [http://creativecommons.org/licenses/by/3.0/ Creative Commons Attribution-Share Alike 3.0 Unported License]

You are free:
*'''to Share''' — to copy, distribute and transmit the work
*'''to Remix''' — to adapt the work

Under the following conditions
*'''Attribution.''' You must attribute the work in the manner specified by the author or licensor (but not in any way that suggests that they endorse you or your use of the work).

# For any reuse or distribution, you must make clear to others the license terms of this work. The best way to do this is with [http://creativecommons.org/licenses/by/3.0/ a link to this web page].
# Any of the above conditions can be waived if you get permission from the copyright holder.
# Nothing in this license impairs or restricts the author's moral rights.

= Disclaimer =
This program is distributed in the hope that it will be useful, but '''WITHOUT ANY WARRANTY'''; without even the implied warranty of '''MERCHANTABILITY''' or '''FITNESS FOR A PARTICULAR PURPOSE'''.

'''IF YOU READ ONE THING IN HERE, READ THIS'''

It is VERY important to remember that there is no such thing as ''cookbook cryptography''! Simply using this cypher does not guarantee security. Security is an end-to-end concern and responsibility lies with you to thoroughly examine your project from all possible angles if valuable data is at risk. If you doubt this, ask any thief how they'd rather break into your house - futzing about with picking a high-security deadbolt on the front door or walking in through the back door that you left open.

= Documentation =
Included at the end of this source listing is a small bit of example code that shows the usage. If you wish to include this implementation in your own work, just replace the example code with your own. Also, please do not reuse or redistribute this work without including the above text attributing this code to its author Morse Dillon, the above GPL statement, and this documentation.

This is an implementation of the XTEA (eXtended Tiny Encryption Algorithm) block cypher. (X)TEA is a very good choice of cipher when security is important but computational power is limited. Although I did a lot of work on this implementation, enormous amounts of credit must be given to the creators of the algorithm and those who came before me to implement it in other languages and computing environments.

''If you do decide to use this code in a project, I'd appreciate hearing about it. You can reach me by e-mail at: morseATmorsedillon.com''

== About TEA ==

The Tiny Encryption Algorithm ([http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm TEA]), was originally designed by David Wheeler and Roger Needham of the Cambridge Computer Laboratory. The [http://www.ftp.cl.cam.ac.uk/ftp/papers/djw-rmn/djw-rmn-tea.html algorithm] itself is not subject to any patents. While the original TEA was found to have some minor weaknesses, the eXtended Tiny Encryption Algorithm ([http://en.wikipedia.org/wiki/XTEA XTEA]) implemented herein addresses these.

''NOTE: XTEA has been superseded by Corrected Block TEA ([http://en.wikipedia.org/wiki/XXTEA XXTEA])''

TEA and its derivatives consist of 64-bit block [http://en.wikipedia.org/wiki/Feistel_cipher Feistel network] with a 128-bit key. This implementation uses six cycles, or rounds, which is less than one would like but still provides a reasonable level of security (16 is sufficient while 8 is enough for most applications). Six is said to achieve theoretically good dispersion, but should more security be desired the number of cycles can easily be modified by changing the CYCLES global variable. Due to the low execution speed of LSL scripts, it's suggested to make this as low as your comfort level allows. Encryption time scales linearly with the number of cycles.

== About this implementation ==
This is a bare bones implementation, and is meant to be included in the body of the script needing encryption facilities or wrapped in a link message handler. If the latter approach is desired, care should be taken to only send link messages to the prim containing this implementation. If ALL_PRIMS is used as the destination, one could link a link message listener to the object and intercept clear-text communications.

If you plan to place this code into the same script as that needing encryption facilities, you need only call the following functions:

<lsl>
string Encrypt(string clearText)
string Decrypt(string cypherText)
</lsl>

Simple as that.

This implementation does not provide any secure key exchange, so in terms of key generation and exchange you're on your own.

The 128-bit key is contained in four LSL integers: KEY1, KEY2, KEY3, and KEY4. These are global variables at the beginning of the source and can be set using a method that works for you.

==Changes==

===Version 1.1===
*Changed to treat [[Right Shift]] as if integers were unsigned

===Version 1.0a - Alpha===
*General optimization to run faster and use less bytecode.
*Encrypt: Pad works differently, no longer extra characters appended to the output.
*TEAEncrypt: Changed the return type
*ord: Added null support.

===Version 1.0===
*Initial Release

== Future Recommendations ==
*Support [[UTF-8]]
*Output to [[Base64]] instead of [[Hex]] strings
*Append hash to the message to verify integrity of data
*Hash clear-text passwords into 128 bit keys
*Upgrade to XXTEA

= Code =

== Original ==
<lsl>

//XTEA Strong Encryption Implementation - Linden Scripting Language (LSL)
//Version 1.0
//Copyright (C) 2007 by Morse Dillon (morseATmorsedillon.com)
//
//This program is free software; you can redistribute it and/or
//modify it under the terms of the GNU General Public License
//as published by the Free Software Foundation; either version 2
//of the License, or (at your option) any later version.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with this program; if not, write to the Free Software
//Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
//02110-1301, USA.
//========================================================================
//
//Included at the end of this source listing is a small bit of example
//code that shows the usage. If you wish to include this implementation
//in your own work, just replace the example code with your own. Also,
//please do not reuse or redistribute this work without including the
//above text attributing this code to its author Morse Dillon, the above
//GPL statement, and this documentation.
//
//This is an implentation of the XTEA (eXtended Tiny Encryption Algorithm)
//block cypher. (X)TEA is a very good choice of cipher when security
//is important but computational power is limited. Although I did a
//lot of work on this implementation, enormous amounts of credit must
//be given to the creators of the algorithm and those who came before
//me to implement it in other languages and computing environments.
//
//***If you do decide to use this code in a project, I'd appreciate
//hearing about it. You can reach me by e-mail at:
//morseATmorsedillon.com
//
//
//ABOUT TEA AND XTEA
//------------------
//TEA was originally designed by David Wheeler and Roger Needham
//of the Cambridge Computer Laboratory. The algorithm itself is not
//subject to any patents. While the original TEA was found to have
//some minor weaknesses, XTEA (implemented herein) addresses these.
//
//TEA and its derivatives consist of 64-bit block Feistel network
//with a 128-bit key. This implementation uses six cycles, or rounds,
//which is less than one would like but still provides a reasonable
//level of security (16 is sufficient while 8 is enough for most
//applications). Six is said to achieve theoretically good dispersion,
//but should more security be desired the number of cycles can easily be
//modified by changing the CYCLES global variable. Due to the low
//execution speed of LSL scripts, it's suggested to make this as low as
//your comfort level allows. Encryption time scales linearly with the
//number of cycles.
//
//For more information about XTEA, see the following:
//
//Original Paper by Walker and Needham
//http://www.ftp.cl.cam.ac.uk/ftp/papers/djw-rmn/djw-rmn-tea.html
//
//Wikipedia on TEA
//http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm
//
//
//ABOUT THIS IMPLEMENTATION
//-------------------------
//This is a barebones implementation, and is meant to be included in
//the body of the script needing encryption facilities or wrapped
//in a link message handler. If the latter approach is desired, care
//should be taken to only send link messages to the prim containing
//this implementation. If ALL_PRIMS is used as the destination,
//one could link a link message listener to the object and intercept
//cleartext communications.
//
//If you plan to place this code into the same script as that needing
//encryption facilities, you need only call the following functions:
//
//string Encrypt(string cleartext)
//string Decrypt(string cyphertext)
//
//Simple as that.
//
//This implementation does not provide any secure key exchange, so in
//terms of key generation and exchange you're on your own.
//
//The 128-bit key is contained in four LSL integers: KEY1, KEY2, KEY3,
//and KEY4. These are global variables at the beginning of the source
//and can be set using a method that works for you.
//
//
//**************IF YOU READ ONE THING IN HERE, READ THIS*******************
//It is VERY important to remember that there is no such thing as
//'cookbook cryptography'! Simply using this cypher does not guarantee
//security. Security is an end-to-end concern and responsibility lies
//with you to thoroughly examine your project from all possible angles
//if valuable data is at risk. If you doubt this, ask any thief how they'd
//rather break into your house - futzing about with picking a high-security
//deadbolt on the front door or walking in through the back door that you
//left open.

//******************USER-CONFIGURABLE GLOBALS BEGIN HERE*******************

//ENCRYPTION KEYS KEY[1-4]
//These together make up the 128-bit XTEA encryption key. See the above
//documentation for details. Whatever you do, don't leave them as the default.
integer KEY1 = 11111111;
integer KEY2 = 22222222;
integer KEY3 = 33333333;
integer KEY4 = 44444444;

//DEBUG_FLAG
//If set to 1, will cause debug text to be printed containing some
//intermediate cleartext/cyphertext and the resultant cyphertext/cleartext.
//Do not leave this enabled in production environments!!!!
integer DEBUG_FLAG = 0;

//COMM_CHANNEL
//Specifies which channel should be used for debug and test harness communication.
integer COMM_CHANNEL = 0;

//CYCLES
//Specifies the number of rounds to be used. See the above documentation for
//details.
integer CYCLES = 6;

//******************USER-CONFIGURABLE GLOBALS END HERE*********************

//Other Globals
list cypherkey = [];
integer delta = 0x9E3779B9;

//Function: ord
//Returns the index of an ASCII character
integer ord(string chr)
{
string ASCII = " \n !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
if(llStringLength(chr) != 1) return -1;
if(chr == " ") return 32;
return llSubStringIndex(ASCII, chr);
}

//Function: chr
//Returns the ASCII character correspondent to index i
string chr(integer i)
{
string ASCII = " \n !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
i %= 127;
return llGetSubString(ASCII, i, i);
}

//Function: DWord2Hex
//Converts a dword containted in a LSL integer to hexadecimal format.
string DWord2Hex(integer m){

string result;
integer i = 0;
integer index = 0;

//Define character string [0-F] for use in building the hex.
string characters = "0123456789ABCDEF";

//Step through 8 times, for a total of 32 bits, 8 nibbles, and 8 hexadecimal digits.
for (i = 0; i < 8; i++){
//Get a nibble by right-shifting and masking off 4 bits.
index = (m >> (i * 4)) & 0xF;
//Grab character from the characters string at index position and add it to the result string.
result = llInsertString(result, 0, llGetSubString(characters,index,index));
}

return result;
}

//Function: Hex2DWword
//Converts a string containing a hexadecimal number to a dword contained in a LSL integer.
integer Hex2DWord(string m){
integer result = 0;
integer i = 0;
string digit;
integer value;
integer index;

string characters = "0123456789ABCDEF";

for (i = 0; i < 8; i++){

index = 8 - (i + 1);
digit = llGetSubString(m,index,index);

value = llSubStringIndex(characters, digit);

result = result | value << (i * 4);

}

return result;
}

//Function: Encrypt
//Takes cleartext string, pads and bitpacks it, then encrypts it using TEAEncrypt().
string Encrypt(string cleartext){

//Initialize variables.
integer dword1 = 0;
integer dword2 = 0;
integer cyphertext_numeric;
list cypherblock;
string cyphertext = "";

//Pad cleartext string to the nearest multiple of 8.
while(llStringLength(cleartext) & 0x7) {
cleartext += " ";
}

//Define more variables pertaining to while loop.
integer stringlength = llStringLength(cleartext);
integer i=0;
integer character;

//Step through cleartext string, encrypting it in 64-bit (8 character) blocks.
while (i < stringlength){

//Pack dword1 with 4 bytes. Do so by bit-shifting in each character.
//4th byte winds up in the most-significant position.
dword1 = ord(llGetSubString(cleartext,i,i));
i++;
dword1 = dword1 | (ord(llGetSubString(cleartext,i,i)) << 8);
i++;
dword1 = dword1 | (ord(llGetSubString(cleartext,i,i)) << 16);
i++;
dword1 = dword1 | (ord(llGetSubString(cleartext,i,i)) << 24);
i++;

//Do it again, this time for dword2
dword2 = ord(llGetSubString(cleartext,i,i));
i++;
dword2 = dword2 | ord(llGetSubString(cleartext,i,i)) << 8;
i++;
dword2 = dword2 | ord(llGetSubString(cleartext,i,i)) << 16;
i++;
dword2 = dword2 | ord(llGetSubString(cleartext,i,i)) << 24;
i++;

//Call TEAencrypt() with dword1, dword2, and the cypher key and store result in cypherblock.
cypherblock = TEAEncrypt(dword1,dword2,cypherkey);

//Convert dword values from cypherblock to hex and append to cyphertext.
cyphertext = cyphertext + DWord2Hex(llList2Integer(cypherblock,0)) + DWord2Hex(llList2Integer(cypherblock,1));

//Reset variables for the next round, just to be safe.
dword1 = 0;
dword2 = 0;
cypherblock = [];

if(DEBUG_FLAG){
llOwnerSay("Pre-Crypt DWords: " + (string)dword1 + "," + (string)dword2);
llOwnerSay("Post-Crypt DWords: " + (string)llList2Integer(cypherblock,1) + "," + (string)llList2Integer(cypherblock,2));
llOwnerSay("Post-Crypt Hex: " + DWord2Hex(llList2Integer(cypherblock,1)) + "," + DWord2Hex(llList2Integer(cypherblock,2)));
}

}

return cyphertext;
}

//Function: Decrypt
//Takes cyphertext, decrypts it with TEADecrypt(), and unpacks it into a string.
string Decrypt(string cyphertext){

//Initialize variables.
string hexvalue1 = "";
string hexvalue2 = "";
integer dword1 = 0;
integer dword2 = 0;
list clearblock = []; //res
string cleartext = "";
integer i;

//Step through cyphertext string, descrypting it block by block.
while (i < llStringLength(cyphertext)){

//Pull first 32 bits worth of hexadecimal into hexvalue1
hexvalue1 += llGetSubString(cyphertext,i,i + 7);
i = i + 8;

//Pull second 32 bits worth of hexadecimal into hexvalue2
hexvalue2 += llGetSubString(cyphertext,i,i + 7);
i = i + 8;

//Convert hexvalues to dwords contained in LSL integers.
dword1 = Hex2DWord(hexvalue1);
dword2 = Hex2DWord(hexvalue2);

//Call TEADecrypt() with dword1, dword2, and the cypher key and store result in clearblock list.
clearblock = TEADecrypt(dword1, dword2, cypherkey);

//Append first 4 characters of ASCII to cleartext string.
//This is done by pulling the decrypted dwords from the clearblock list and looking up their ASCII values.
cleartext += chr( llList2Integer(clearblock,0) & 0x000000FF);
cleartext += chr( (llList2Integer(clearblock,0) & 0x0000FF00) >> 8);
cleartext += chr( (llList2Integer(clearblock,0) & 0x00FF0000) >> 16);
cleartext += chr( (llList2Integer(clearblock,0) & 0xFF000000) >> 24);

//Append second 4 characters of ASCII to cleartext string.
cleartext += chr( llList2Integer(clearblock,1) & 0x000000FF);
cleartext += chr( (llList2Integer(clearblock,1) & 0x0000FF00) >> 8);
cleartext += chr( (llList2Integer(clearblock,1) & 0x00FF0000) >> 16);
cleartext += chr( (llList2Integer(clearblock,1) & 0xFF000000) >> 24);

//Reset variables for the next two blocks of decrypt.
hexvalue1 = "";
hexvalue2 = "";
dword1 = 0;
dword2 = 0;
clearblock = [];

if(DEBUG_FLAG){
llOwnerSay("Pre-Decrypt Hex: " + hexvalue1 + "," + hexvalue2);
llOwnerSay("Pre-Decrypt DWords: " + (string)dword1 + "," + (string)dword2);
llOwnerSay("Post-Decrypt DWords: " + (string)llList2Integer(clearblock,1) + "," + (string)llList2Integer(clearblock,2));
}

}

return cleartext;
}

//Function: TEAEncrypt
//This is the implementation of XTEA proper. It takes a block of cleartext
//consisting of two dwords contained in LSL integers and a 128-bit key
//contained in an LSL list of 4 integers. The function then returns
//the cyphertext in an LSL list of two integers.
list TEAEncrypt(integer dword1, integer dword2,list cypherkey){

list cryptlist = [];

//Set n to the number of cycles given in the CYCLES global variable
integer n = CYCLES;

integer sum = 0;

//Operate for the specified number of cycles.
while (n-- > 0){
dword1 = dword1 + ( ( dword2 << 4 ^ ((dword2 >> 5) & 0x07FFFFFF) ) + dword2 ^ sum + llList2Integer(cypherkey, (sum & 3) ) );
sum += delta;
dword2 = dword2 + ( ( dword1 << 4 ^ ((dword1 >> 5) & 0x07FFFFFF) ) + dword1 ^ sum + llList2Integer(cypherkey, ((sum >> 11) & 3) ) );
}

cryptlist = [dword1,dword2];

return cryptlist;
}

//Function: TEADecrypt
//This is the implementation of XTEA proper. It takes a block of cyphertext
//consisting of two dwords contained in LSL integers and a 128-bit key
//contained in an LSL list of 4 integers. The function then returns
//the cleartext in an LSL list of two integers.
list TEADecrypt(integer dword1, integer dword2,list cypherkey){

list cryptlist = [];

//Set n to the number of cycles given in the CYCLES global variable
integer n = CYCLES;

integer sum = delta * CYCLES;

//Operate for the specified number of cycles.
while (n-- > 0){
dword2 = dword2 - ( ( dword1 << 4 ^ ((dword1 >> 5) & 0x07FFFFFF) ) + dword1 ^ sum + llList2Integer(cypherkey, ((sum >> 11) & 3) ) );
sum -= delta;
dword1 = dword1 - ( ( dword2 << 4 ^ ((dword2 >> 5) & 0x07FFFFFF) ) + dword2 ^ sum + llList2Integer(cypherkey, (sum & 3) ) );
}

cryptlist = [dword1,dword2];
return cryptlist;
}
</lsl>

== Usage Example ==
Listens on COMM_CHANNEL for a message and encrypts it, then turns around and decrypts the resultant cypher-text. Object than says the encrypted and decrypted messages to the owner.
<lsl>
default
{
state_entry()
{
llListen(COMM_CHANNEL, "", NULL_KEY, "");
cypherkey = [KEY1,KEY2,KEY3,KEY4];
}

listen(integer channel, string name, key id, string message)
{
string temp_cyphertext = Encrypt(message);

string temp_cleartext = Decrypt(temp_cyphertext);

llOwnerSay("\nOriginal Cleartext: " + message + "\nCyphertext: " + temp_cyphertext + "\nDecrypted Cleartext: " + temp_cleartext);
}
}
</lsl>

== Optimized ==
This version is untested but if it works should run faster (and be able to handle larger strings).

<lsl>
// Include the documentation comments from above (separated here only for easier management)

//XTEA Strong Encryption Implementation - Linden Scripting Language (LSL)
//Version 1.0a Alpha
//Copyright (C) 2007 by Strife Onizuka (blindwandererATgmail.com)
//
//Version 1.0
//Copyright (C) 2007 by Morse Dillon (morseATmorsedillon.com)
//
//This program is free software; you can redistribute it and/or
//modify it under the terms of the GNU General Public License
//as published by the Free Software Foundation; either version 2
//of the License, or (at your option) any later version.
//
//This program is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
//GNU General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with this program; if not, write to the Free Software
//Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
//02110-1301, USA.
//========================================================================
//
//Included at the end of this source listing is a small bit of example
//code that shows the usage. If you wish to include this implementation
//in your own work, just replace the example code with your own. Also,
//please do not reuse or redistribute this work without including the
//above text attributing this code to its author Morse Dillon, the above
//GPL statement, and this documentation.
//
//This is an implentation of the XTEA (eXtended Tiny Encryption Algorithm)
//block cypher. (X)TEA is a very good choice of cipher when security
//is important but computational power is limited. Although I did a
//lot of work on this implementation, enormous amounts of credit must
//be given to the creators of the algorithm and those who came before
//me to implement it in other languages and computing environments.
//
//***If you do decide to use this code in a project, I'd appreciate
//hearing about it. You can reach me by e-mail at:
//morseATmorsedillon.com
//
//
//ABOUT TEA AND XTEA
//------------------
//TEA was originally designed by David Wheeler and Roger Needham
//of the Cambridge Computer Laboratory. The algorithm itself is not
//subject to any patents. While the original TEA was found to have
//some minor weaknesses, XTEA (implemented herein) addresses these.
//
//TEA and its derivatives consist of 64-bit block Feistel network
//with a 128-bit key. This implementation uses six cycles, or rounds,
//which is less than one would like but still provides a reasonable
//level of security (16 is sufficient while 8 is enough for most
//applications). Six is said to achieve theoretically good dispersion,
//but should more security be desired the number of cycles can easily be
//modified by changing the CYCLES global variable. Due to the low
//execution speed of LSL scripts, it's suggested to make this as low as
//your comfort level allows. Encryption time scales linearly with the
//number of cycles.
//
//For more information about XTEA, see the following:
//
//Original Paper by Walker and Needham
//http://www.ftp.cl.cam.ac.uk/ftp/papers/djw-rmn/djw-rmn-tea.html
//
//Wikipedia on TEA
//http://en.wikipedia.org/wiki/Tiny_Encryption_Algorithm
//
//
//ABOUT THIS IMPLEMENTATION
//-------------------------
//This is a barebones implementation, and is meant to be included in
//the body of the script needing encryption facilities or wrapped
//in a link message handler. If the latter approach is desired, care
//should be taken to only send link messages to the prim containing
//this implementation. If ALL_PRIMS is used as the destination,
//one could link a link message listener to the object and intercept
//cleartext communications.
//
//If you plan to place this code into the same script as that needing
//encryption facilities, you need only call the following functions:
//
//string Encrypt(string cleartext)
//string Decrypt(string cyphertext)
//
//Simple as that.
//
//This implementation does not provide any secure key exchange, so in
//terms of key generation and exchange you're on your own.
//
//The 128-bit key is contained in four LSL integers: KEY1, KEY2, KEY3,
//and KEY4. These are global variables at the beginning of the source
//and can be set using a method that works for you.
//
//
//CHANGES
//-------
//
//1.0a - Alpha
//*General optimization to run faster and use less bytecode.
//*Encrypt: Pad works differently, no longer extra characters appended to the output.
//*TEAEncrypt: Changed the return type
//*ord: Added null support.
//
//1.0
//*Initial Release
//
//
//FUTURE CHANGES
//--------------
//
//It would be nice if it supported UTF-8; but adding that would be alot
//of work. The main issue is the decoding, the bytes would have to be
//reassembled into characters. It would be time consuming. Another possibility
//would be to implement XTEA to output to BASE64 instead of hex strings (also
//time consuming to implement).
//
//
//**************IF YOU READ ONE THING IN HERE, READ THIS*******************
//It is VERY important to remember that there is no such thing as
//'cookbook cryptography'! Simply using this cypher does not guarantee
//security. Security is an end-to-end concern and responsibility lies
//with you to thoroughly examine your project from all possible angles
//if valuable data is at risk. If you doubt this, ask any thief how they'd
//rather break into your house - futzing about with picking a high-security
//deadbolt on the front door or walking in through the back door that you
//left open.

//******************USER-CONFIGURABLE GLOBALS BEGIN HERE*******************

//ENCRYPTION KEYS KEY[1-4]
//These together make up the 128-bit XTEA encryption key. See the above
//documentation for details. Whatever you do, don't leave them as the default.
//Don't be stupid and make it obvious like your av's key.
integer KEY1 = 11111111;
integer KEY2 = 22222222;
integer KEY3 = 33333333;
integer KEY4 = 44444444;

//COMM_CHANNEL
//Specifies which channel should be used for debug and test harness communication.
integer COMM_CHANNEL = 0;

//CYCLES
//Specifies the number of rounds to be used. See the above documentation for
//details.
integer CYCLES = 6;

//******************USER-CONFIGURABLE GLOBALS END HERE*********************

//Other Globals
list cypherkey = [];
integer delta = 0x9E3779B9;

string ASCII = " \n !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~";
string characters = "0123456789ABCDEF";

//Function: ord
//Returns the index of an ASCII character
integer ord(string chr)
{
if(chr)
{
if(llStringLength(chr) > 1) return -1;
if(chr == " ") return 32;
return llSubStringIndex(ASCII, chr);
}
return 0;
}

//Function: chr
//Returns the ASCII character correspondent to index i
string chr(integer i)
{
if(i)
return llGetSubString(ASCII, i %= 127, i);
return "";
}

//Function: DWord2Hex
//Converts a dword contained in a LSL integer to hexadecimal format.
string DWord2Hex(integer m)
{
string result;
integer i = 0;

//Define character string [0-F] for use in building the hex.
//Step through 8 times, for a total of 32 bits, 8 nibbles, and 8 hexadecimal digits.
do{
integer index = (m >> i) & 0xF;
result = llGetSubString(characters, index, index) + result;
}while((i += 4) < 32);
return result;
}

//Function: Encrypt
//Takes cleartext string, pads and bitpacks it, then encrypts it using TEAEncrypt().
string Encrypt(string cleartext)
{
string cyphertext = "";
integer i = llStringLength(cleartext);
if((i += (0x7 & -i)))//Pad cleartext string to the nearest multiple of 8.
{
//Step through cleartext string backwords, encrypting it in 64-bit (8 character) blocks.
do{
//i=~-i is the same as --i, just a bit faster and lighter on bytecode; requires one less stack manipulation.
//Pack dword1 with 4 bytes. Do so by bit-shifting in each character.
//4th byte winds up in the most-significant position.
integer dword2 = ( ord(llGetSubString(cleartext,i=~-i,i)) ) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 8 ) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 16) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 24) ;

//Do it again, this time for dword1
integer dword1 = ( ord(llGetSubString(cleartext,i=~-i,i)) ) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 8 ) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 16) |
( ord(llGetSubString(cleartext,i=~-i,i)) << 24) ;

//Call TEAencrypt() with dword1, dword2, and the cypher key and store result in cypherblock.

//Convert dword values from cypherblock to hex and append to cyphertext.
cyphertext = TEAEncrypt(dword1,dword2,cypherkey) + cyphertext;
}while(i);
}
return cyphertext;
}

//Function: Decrypt
//Takes cyphertext, decrypts it with TEADecrypt(), and unpacks it into a string.
string Decrypt(string cyphertext){

//Initialize variables.
string cleartext = "";
integer i = -llStringLength(cyphertext);

//Step through cyphertext string, decrypting it block by block.
if((i -= (0xF & i)))//Pad cyphertext string to the nearest multiple of 16.
{
do
{

//Convert hexvalues to dwords contained in LSL integers.
//Call TEADecrypt() with dword1, dword2, and the cypher key and store result in clearblock list.
list clearblock = TEADecrypt((integer)("0x"+llGetSubString(cyphertext,i, ~-(i -= 8))),
(integer)("0x"+llGetSubString(cyphertext,i, ~-(i -= 8))), cypherkey);

//Append first 4 characters of ASCII to cleartext string.
//This is done by pulling the decrypted dwords from the clearblock list and looking up their ASCII values.
integer t = llList2Integer(clearblock,1);
cleartext += chr( (t ) & 0xFF) +
chr( (t >> 8 ) & 0xFF) +
chr( (t >> 16) & 0xFF) +
chr( (t = llList2Integer(clearblock,0) >> 24) & 0xFF) +
chr( (t ) & 0xFF) +
chr( (t >> 8 ) & 0xFF) +
chr( (t >> 16) & 0xFF) +
chr( (t >> 24) & 0xFF) ;
}while(i);
}
return cleartext;
}

//Function: TEADecrypt
//This is the implementation of XTEA proper. It takes a block of cleartext
//consisting of two dwords contained in LSL integers and a 128-bit key
//contained in an LSL list of 4 integers. The function then returns
//the cyphertext in an LSL list of two integers.
string TEAEncrypt(integer dword1, integer dword2, list cypherkey_)
{
if(CYCLES > 0)//$[E20011] /*lslint ignore*/
{
//Set n to the number of cycles given in the CYCLES global variable
integer n = CYCLES;
integer sum = 0;
//Operate for the specified number of cycles.
do{
dword1 = dword1 + ( ( dword2 << 4 ^ dword2 >> 5 ) + dword2 ^ sum + llList2Integer(cypherkey_, (sum & 3) ) );
dword2 = dword2 + ( ( dword1 << 4 ^ dword1 >> 5 ) + dword1 ^ sum + llList2Integer(cypherkey_, ((sum += delta) >> 11 & 3) ) );
}while (n = ~-n);
}
return DWord2Hex(dword1) + DWord2Hex(dword2);
}

//Function: TEADecrypt
//This is the implementation of XTEA proper. It takes a block of cyphertext
//consisting of two dwords contained in LSL integers and a 128-bit key
//contained in an LSL list of 4 integers. The function then returns
//the cleartext in an LSL list of two integers.
list TEADecrypt(integer dword1, integer dword2,list cypherkey_)
{
if(CYCLES > 0)//$[E20011] /*lslint ignore*/
{
//Set n to the number of cycles given in the CYCLES global variable
integer n = CYCLES;
integer sum = delta * CYCLES;
//Operate for the specified number of cycles.
do{
dword2 = dword2 - ( ( dword1 << 4 ^ dword1 >> 5 ) + dword1 ^ sum + llList2Integer(cypherkey_, (sum >> 11 & 3) ) );
dword1 = dword1 - ( ( dword2 << 4 ^ dword2 >> 5 ) + dword2 ^ sum + llList2Integer(cypherkey_, ((sum -= delta) & 3) ) );
}while (n = ~-n);
}
return [dword1,dword2];
}

//XTEA Usage Example
//Listens on COMM_CHANNEL for a message and encrypts it, then turns around and decrypts the resultant cyphertext.
//Object than says the encrypted and decrypted messages to the owner.
default
{
state_entry()
{
llListen(COMM_CHANNEL, "", NULL_KEY, "");
cypherkey = [KEY1,KEY2,KEY3,KEY4];
}

listen(integer channel, string name, key id, string message)
{
string temp_cyphertext = Encrypt(message);

string temp_cleartext = Decrypt(temp_cyphertext);

llOwnerSay("\nOriginal Cleartext: " + message + "\nCyphertext: " + temp_cyphertext + "\nDecrypted Cleartext: " + temp_cleartext);
}
}
</lsl>

== XTEA LSL <-> PHP ==
This is an XTEA implementation that has both LSL and PHP scripts to allow strong encryption not only inside LSL but also between LSL and a PHP serverscript.

For those who want to see this in action with your Web server try these. Be sure that if you edit these that Rounds and Key Phrase are the same in both LSL and PHP versions.

LSL - PLACE IN PRIM -- Edit to change URL and tosend text.

<lsl>

//************************************************//
//* Masa's XTEA encryption/decryption v3 *//
//* Modified by SleightOf Hand for Stability and *//
//* intercommunication with PHP version *//
//************************************************//
// NOTE: This version only encodes 60 bits per 64-bit block!
// This code is public domain.
// Sleight was here 20070522
// masa was here 20070315
// so was strife 20070315
// so was adz 20070812
//
// This was Modified by SleightOf Hand to allow
// Strong encryption between LSL and PHP.
//************************************************//
//* XTEA IMPLEMENTATION *//
//************************************************//

integer XTEA_DELTA = 0x9E3779B9; // (sqrt(5) - 1) * 2^31
integer xtea_num_rounds = 6;
list xtea_key = [0, 0, 0, 0];

integer hex2int(string hex) {
if(llGetSubString(hex,0,1) == "0x")
return (integer)hex;
if(llGetSubString(hex,0,0) == "x")
return (integer)("0"+hex);
return(integer)("0x"+hex);
}

// Convers any string to a 32 char MD5 string and then to a list of
// 4 * 32 bit integers = 128 bit Key. MD5 ensures always a specific
// 128 bit key is generated for any string passed.
list xtea_key_from_string( string str )
{
str = llMD5String(str,0); // Use Nonce = 0
return [ hex2int(llGetSubString( str, 0, 7)),
hex2int(llGetSubString( str, 8, 15)),
hex2int(llGetSubString( str, 16, 23)),
hex2int(llGetSubString( str, 24, 31))];
}

// Encipher two integers and return the result as a 12-byte string
// containing two base64-encoded integers.
string xtea_encipher( integer v0, integer v1 )
{
integer num_rounds = xtea_num_rounds;
integer sum = 0;
do {
// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.
v0 += (((v1 << 4) ^ ((v1 >> 5) & 0x07FFFFFF)) + v1) ^ (sum + llList2Integer(xtea_key, sum & 3));
sum += XTEA_DELTA;
v1 += (((v0 << 4) ^ ((v0 >> 5) & 0x07FFFFFF)) + v0) ^ (sum + llList2Integer(xtea_key, (sum >> 11) & 3));

} while( num_rounds = ~-num_rounds );
//return only first 6 chars to remove "=="'s and compact encrypted text.
return llGetSubString(llIntegerToBase64(v0),0,5) +
llGetSubString(llIntegerToBase64(v1),0,5);
}

// Decipher two base64-encoded integers and return the FIRST 30 BITS of
// each as one 10-byte base64-encoded string.
string xtea_decipher( integer v0, integer v1 )
{
integer num_rounds = xtea_num_rounds;
integer sum = XTEA_DELTA*xtea_num_rounds;
do {
// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.
v1 -= (((v0 << 4) ^ ((v0 >> 5) & 0x07FFFFFF)) + v0) ^ (sum + llList2Integer(xtea_key, (sum>>11) & 3));
sum -= XTEA_DELTA;
v0 -= (((v1 << 4) ^ ((v1 >> 5) & 0x07FFFFFF)) + v1) ^ (sum + llList2Integer(xtea_key, sum & 3));
} while ( num_rounds = ~-num_rounds );

return llGetSubString(llIntegerToBase64(v0), 0, 4) +
llGetSubString(llIntegerToBase64(v1), 0, 4);
}

// Encrypt a full string using XTEA.
string xtea_encrypt_string( string str )
{
// encode string
str = llStringToBase64(str);
// remove trailing =s so we can do our own 0 padding
integer i = llSubStringIndex( str, "=" );
if ( i != -1 )
str = llDeleteSubString( str, i, -1 );

// we don't want to process padding, so get length before adding it
integer len = llStringLength(str);

// zero pad
str += "AAAAAAAAAA=";

string result;
i = 0;

do {
// encipher 30 (5*6) bits at a time.
result += xtea_encipher(
llBase64ToInteger(llGetSubString(str, i, i += 4) + "A="),
llBase64ToInteger(llGetSubString(str, ++i, i += 4) + "A=")
);
} while ( ++i < len );

return result;
}

// Decrypt a full string using XTEA
string xtea_decrypt_string( string str ) {
integer len = llStringLength(str);
integer i;
string result;
do {
result += xtea_decipher(
llBase64ToInteger(llGetSubString(str, i, i += 5) + "=="),
llBase64ToInteger(llGetSubString(str, ++i, i += 5) + "==")
);
} while ( ++i < len );

// Replace multiple trailing zeroes with a single one
i = llStringLength(result) - 1;
while ( llGetSubString(result, --i, i+1) == "AA" )
result = llDeleteSubString(result, i+1, i+1);
return llBase64ToString( result + "====" );
}

key requestid; // just to check if we're getting the result we've asked for; all scripts in the same object get the same replies
string base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +

"abcdefghijklmnopqrstuvwxyz" +

"0123456789+/";
string url = "http://<enter your URL here>/test-script.php";

default
{
touch_start(integer number)
{
string tosend = "this is a message to send";
llWhisper(0, "Message to Send = " + tosend);
xtea_key = xtea_key_from_string("this is a test key");
string message = xtea_encrypt_string(tosend);
llWhisper(0, "Message to Server = " + message);
requestid = llHTTPRequest(url,
[HTTP_METHOD, "POST",
HTTP_MIMETYPE, "application/x-www-form-urlencoded"],
"parameter1=" + llEscapeURL(message));
}

http_response(key request_id, integer status, list metadata, string body)
{
if (request_id == requestid) {
llWhisper(0, "Web server sent: " + body);
integer clean = 0;
string cleanbody = "";
while(~llSubStringIndex(base64,llGetSubString(body,clean,clean))){
cleanbody += llGetSubString(body,clean,clean++);
}
llWhisper(0, "Cleaned : " + cleanbody);
llWhisper(0, "Web server said: " + xtea_decrypt_string( cleanbody ));
}
}
}

</lsl>

PHP Code - Place on web server at location that LSL URL will be looking for.

<php>
//************************************************//
//* Sleight's PHP XTEA encryption/decryption v3 *//
//* Modified by SleightOf Hand for Stability and *//
//* intercommunication between PHP & LSL *//
//************************************************//
// NOTE: This version only encodes 60 bits per 64-bit block!
// This code is public domain.
// Sleight was here 20070522
// masa was here 20070315
// so was strife 20070315
// so was adz 20080812
//
// This was converted from the LSL version by
// SleightOf Hand to allow Strong encryption
// between LSL and PHP. If you find this usefull
// any donations apreciated.
//************************************************//
//* XTEA IMPLEMENTATION *//
//************************************************//

$_XTEA_DELTA = 0x9E3779B9; // (sqrt(5) - 1) * 2^31
$_xtea_num_rounds = 6;
$_xtea_key = array(0, 0, 0, 0);
$_base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".
"abcdefghijklmnopqrstuvwxyz".
"0123456789+/";

// Returns Integer based on 8 byte Base64 Code XXXXXX== (llBase64ToInteger)
function base64_integer($str){
global $_base64;
if(strlen($str) != 8) return 0;
return ((strpos($_base64,$str{0}) << 26)|
(strpos($_base64,$str{1}) << 20)|
(strpos($_base64,$str{2}) << 14)|
(strpos($_base64,$str{3}) << 8) |
(strpos($_base64,$str{4}) << 2) |
(strpos($_base64,$str{5}) >> 4));
}

// Returns 8 Byte Base64 code based on 32 bit integer ((llIntegerToBase64)
function integer_base64($int){
global $_base64;
if($int != (integer) $int) return 0;
return $_base64{($int >> 26 & 0x3F)} .
$_base64{($int >> 20 & 0x3F)} .
$_base64{($int >> 14 & 0x3F)} .
$_base64{($int >> 8 & 0x3F)} .
$_base64{($int >> 2 & 0x3F)} .
$_base64{($int << 4 & 0x3F)} . "==";
}

//strict 32 bit addition using logic
function binadd($val1 , $val2){
$tc = $val1 & $val2;
$ta = $val1 ^ $val2;
do{
$tac = ($tc << 1) & 0x0FFFFFFFF;
$tc = $ta & $tac;
$ta = $ta ^ $tac;
}while($tc);
return $ta; // $ta will now be the result so return it
}

// Convers any string to a 32 char MD5 string and then to a list of
// 4 * 32 bit integers = 128 bit Key.
function xtea_key_from_string( $str ) {
global $_xtea_key;
$str = md5($str . ":0"); // Use nonce = 0 in LSL for same output
eval("\$_xtea_key[0] = 0x" . substr($str,0,8) . ";");
eval("\$_xtea_key[1] = 0x" . substr($str,8,8) . ";");
eval("\$_xtea_key[2] = 0x" . substr($str,16,8) . ";");
eval("\$_xtea_key[3] = 0x" . substr($str,24,8) . ";");
}

// Encipher two integers and return the result as a 12-byte string
// containing two base64-encoded integers.
function xtea_encipher( $v0 , $v1 ) {
global $_xtea_num_rounds , $_xtea_key , $_XTEA_DELTA;
$num_rounds = $_xtea_num_rounds;
$sum = 0;
do {
// LSL only has 32 bit integers. However PHP automaticly changes
// 32 bit integers to 64 bit floats as nessesary. This causes
// incompatibilities between the LSL Encryption and the PHP
// counterpart. I got round this by changing all addition to
// binary addition using logical & and ^ and loops to handle bit
// carries. This forces the 32 bit integer to remain 32 bits as
// I mask out any carry over 32 bits. this bring the output of the
// encrypt routine to conform with the output of its LSL counterpart.

// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.

// calculate ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
$v0a = binadd((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) , $v1);
// calculate ($sum + $_xtea_key[$sum & 3])
$v0b = binadd($sum , $_xtea_key[$sum & 3]);
// Calculate ($v0 + ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
// ^ ($sum + $_xtea_key[$sum & 3]))
$v0 = binadd($v0 , ($v0a ^ $v0b));

//Calculate ($sum + $_XTEA_DELTA)
$sum = binadd($sum , $_XTEA_DELTA);

//Calculate ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
$v1a = binadd((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) , $v0);
// Calculate ($sum + $_xtea_key[($sum >>11) & 3])
$v1b = binadd($sum , $_xtea_key[($sum >>11) & 3]);
//Calculate ($v1 + ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0
// ^ ($sum & $_xtea_key[($sum >>11) & 3]))
$v1 = binadd($v1 , ($v1a ^ $v1b));
} while( $num_rounds = ~-$num_rounds );
//return only first 6 chars to remove "=="'s and compact encrypted text.
return substr(integer_base64($v0),0,6) . substr(integer_base64($v1),0,6);
}

// Decipher two base64-encoded integers and return the FIRST 30 BITS of
// each as one 10-byte base64-encoded string.
function xtea_decipher( $v0, $v1 ) {
global $_xtea_num_rounds , $_xtea_key , $_XTEA_DELTA;
$num_rounds = $_xtea_num_rounds;
$sum = 0; // $_XTEA_DELTA * $_xtea_num_rounds;
$tda = $_XTEA_DELTA;
do{ // Binary multiplication using binary manipulation
if($num_rounds & 1){
$sum = binadd($sum , $tda);
}
$num_rounds = $num_rounds >> 1;
$tda = ($tda << 1) & 0x0FFFFFFFF;
}while($num_rounds);
$num_rounds = $_xtea_num_rounds; // reset $num_rounds back to its propper setting;

do {
// LSL only has 32 bit integers. However PHP automaticly changes
// 32 bit integers to 64 bit floats as nessesary. This causes
// incompatibilities between the LSL Encryption and the PHP
// counterpart. I got round this by changing all addition to
// binary addition using logical & and ^ and loops to handle bit
// carries. This forces the 32 bit integer to remain 32 bits as
// I mask out any carry over 32 bits. this bring the output of the
// decrypt routine to conform with the output of its LSL counterpart.
// Subtrations are handled by using 2's compliment

// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.

// calculate ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
$v1a = binadd((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) , $v0);
// calculate ($sum + $_xtea_key[($sum>>11) & 3])
$v1b = binadd($sum , $_xtea_key[($sum>>11) & 3]);
//Calculate 2's compliment of ($v1a ^ $v1b) for subtraction
$v1c = binadd((~($v1a ^ $v1b)) , 1);
//Calculate ($v1 - ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
// ^ ($sum + $_xtea_key[($sum>>11) & 3]))
$v1 = binadd($v1 , $v1c);

// Calculate new $sum based on $num_rounds - 1
$tnr = $num_rounds - 1; // Temp $num_rounds
$sum = 0; // $_XTEA_DELTA * ($num_rounds - 1);
$tda = $_XTEA_DELTA;
do{ // Binary multiplication using binary manipulation
if($tnr & 1){
$sum = binadd($sum , $tda);
}
$tnr = $tnr >> 1;
$tda = ($tda << 1) & 0x0FFFFFFFF;
}while($tnr);

//Calculate ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
$v0a = binadd((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) , $v1);
//Calculate ($sum + $_xtea_key[$sum & 3])
$v0b = binadd($sum , $_xtea_key[$sum & 3]);
//Calculate 2's compliment of ($v0a ^ $v0b) for subtraction
$v0c = binadd((~($v0a ^ $v0b)) , 1);
//Calculate ($v0 - ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1
// ^ ($sum + $_xtea_key[$sum & 3]))
$v0 = binadd($v0 , $v0c);
} while ( $num_rounds = ~-$num_rounds );

return substr(integer_base64($v0), 0, 5) . substr(integer_base64($v1), 0, 5);
}

// Encrypt a full string using XTEA.
function xtea_encrypt_string( $str ) {
// encode Binany string to Base64
$str = base64_encode($str);

// remove trailing =s so we can do our own 0 padding
$i = strpos($str, '=', 0);
if ( $i !== FALSE ){
$str = substr( $str, 0, $i);
}
// we don't want to process padding, so get length before adding it
$len = strlen($str);
// zero pad
$str .= "AAAAAAAAAA=";
$result = "";
$i = 0;

do {
// encipher 30 (5*6) bits at a time.
$enc1 = base64_integer(substr($str , $i , 5) . "A==");
$i += 5;
$enc2 = base64_integer(substr($str , $i , 5) . "A==");
$i += 5;
$result .= xtea_encipher($enc1, $enc2);
} while ( $i < $len );
return $result; //Return Encrypted string
}

// Decrypt a full string using XTEA
function xtea_decrypt_string( $str ) {
global $_base64 ;

$len = strlen($str);
$i;
$result;
do {
$dec1 = base64_integer(substr($str , $i , 6)."==");
$i += 6;
$dec2 = base64_integer(substr($str , $i , 6)."==");
$i += 6;
$result .= xtea_decipher( $dec1, $dec2);
} while ( $i < $len );

// Replace multiple trailing zeroes with a single one
$result = rtrim($result, "A");
$i = strlen($result);
$mod = $i%4; //Depending on encoded length diffrent appends are needed
if($mod == 1) $result .= "A==";
else if($mod == 2 ) $result .= "==";
else if($mod == 3) $result .= "=";

return base64_decode( $result );
}

// Only works with PHP compiled as an Apache module
$headers = apache_request_headers();

$objectName = $headers["X-SecondLife-Object-Name"];
$objectKey = $headers["X-SecondLife-Object-Key"];
$ownerKey = $headers["X-SecondLife-Owner-Key"];
$ownerName = $headers["X-SecondLife-Owner-Name"];
$region = $headers["X-SecondLife-Region"];
// and so on for getting all the other variables ...

//to pull out this headers in other kinds of installations, use this (Adz)
/*
$objectName = $_SERVER['HTTP_X_SECONDLIFE_OBJECT_NAME'];
$objectKey = $_SERVER['HTTP_X_SECONDLIFE_OBJECT_KEY'];
$region = $_SERVER['HTTP_X_SECONDLIFE_REGION'];
$ownerName = $_SERVER['HTTP_X_SECONDLIFE_OWNER_NAME'];
$ownerKey = $_SERVER['HTTP_X_SECONDLIFE_OWNER_KEY'];
*/

xtea_key_from_string("this is a test key");
// get things from $_POST[]
// Naturally enough, if this is empty, you won't get anything
$parameter1 = xtea_decrypt_string($_POST["parameter1"]);

echo xtea_encrypt_string($ownerName . " just said " . $parameter1) . "\n";
</php>

This should result in the following output.

Object whispers: Message to Send = this is a message to send<br/>
Object whispers: Message to Server = JSdgCA0FDyhgLlUnSgqMQWkAxz1AzA1vr9zwSEDnCgwJ6GNQ<br />
Object whispers: Web server sent: SVbqNQ5XdkngeUI3bgP+s6eAT6GM4AWnYCYApcfxagrPbxmwiY7WXA4J+gEQ1AYhRQNvcnEwfZSo/AuKVtIw<br />
Object whispers: Cleaned : SVbqNQ5XdkngeUI3bgP+s6eAT6GM4AWnYCYApcfxagrPbxmwiY7WXA4J+gEQ1AYhRQNvcnEwfZSo/AuKVtIw<br />
Object whispers: Web server said: SleightOf Hand just said this is a message to send

PHP 5 class of XTEA

<php>
<?php
// http://wiki.secondlife.com/wiki/XTEA_Strong_Encryption_Implementation
//************************************************//
//* Sleight's PHP XTEA encryption/decryption v3 *//
//* Modified by SleightOf Hand for Stability and *//
//* intercommunication between PHP & LSL *//
//************************************************//
// NOTE: This version only encodes 60 bits per 64-bit block!
// This code is public domain.
// Sleight was here 20070522
// masa was here 20070315
// so was strife 20070315
// so was adz 20080812
// gave this some class 20080201 JB Kraft
//
// This was converted from the LSL version by
// SleightOf Hand to allow Strong encryption
// between LSL and PHP. If you find this usefull
// any donations apreciated.
//************************************************//
//* XTEA IMPLEMENTATION *//
//************************************************//

/**
* PHP 5 class to do XTEA crypting
*
* $xtea = new XTEA( "mypassword" );
* $crypted = $xtea->encrypt( "Some bogus string" );
* echo "Encrypted: " . bin2hex($crypted);
* echo "Decrypted: " . $xtea->decrypt( $crypted );
*
* @package whatevah
* @author JB Kraft
**/
class XTEA
{

private $_XTEA_DELTA = 0x9E3779B9; // (sqrt(5) - 1) * 2^31
private $_xtea_num_rounds = 6;
private $_xtea_key = array(0, 0, 0, 0);
private $_base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

/**
* CTOR
*
* @param $passwd the password to use for crypting
* @author JB Kraft
**/
public function __construct( $passwd )
{
$this->xtea_key_from_string( $passwd );
}

/**
* Encrypt a full string using XTEA.
*
* @param $str the string to encrypt
* @return the encrypted string
* @author JB Kraft
**/
public function encrypt( $str )
{
// encode Binany string to Base64
$str = base64_encode($str);

// remove trailing =s so we can do our own 0 padding
$i = strpos($str, '=', 0);
if ( $i !== FALSE ){
$str = substr( $str, 0, $i);
}
// we don't want to process padding, so get length before adding it
$len = strlen($str);
// zero pad
$str .= "AAAAAAAAAA=";
$result = "";
$i = 0;

do {
// encipher 30 (5*6) bits at a time.
$enc1 = $this->base64_integer(substr($str , $i , 5) . "A==");
$i += 5;
$enc2 = $this->base64_integer(substr($str , $i , 5) . "A==");
$i += 5;
$result .= $this->xtea_encipher($enc1, $enc2);
} while ( $i < $len );
return $result; //Return Encrypted string
}

/**
* Decrypt a full string using XTEA
*
* @param $str the string to decrypt
* @return the decrypted string
* @author JB Kraft
**/
public function decrypt( $str )
{
$len = strlen($str);
$i = 0;
$result = '';
do {
$dec1 = $this->base64_integer(substr($str , $i , 6)."==");
$i += 6;
$dec2 = $this->base64_integer(substr($str , $i , 6)."==");
$i += 6;
$result .= $this->xtea_decipher( $dec1, $dec2);
} while ( $i < $len );

// Replace multiple trailing zeroes with a single one
$i = strlen($result);
while ( substr($result, --$i, 1) == "A" );
$result = substr($result, 0, $i+1);
$i = strlen($result);
$mod = $i%4; //Depending on encoded length diffrent appends are needed
if($mod == 1) $result .= "A==";
else if($mod == 2 ) $result .= "==";
else if($mod == 3) $result .= "=";

return base64_decode( $result );
}

// -----------------------------
// stuff below here is protected
// -----------------------------

// Returns Integer based on 8 byte Base64 Code XXXXXX== (llBase64ToInteger)
protected function base64_integer($str)
{
if(strlen($str) != 8) return 0;
return ((strpos($this->_base64,$str{0}) << 26)|
(strpos($this->_base64,$str{1}) << 20)|
(strpos($this->_base64,$str{2}) << 14)|
(strpos($this->_base64,$str{3}) << 8) |
(strpos($this->_base64,$str{4}) << 2) |
(strpos($this->_base64,$str{5}) >> 4));
}

// Returns 8 Byte Base64 code based on 32 bit integer ((llIntegerToBase64)
protected function integer_base64($int)
{
if($int != (integer) $int) return 0;
return $this->_base64{($int >> 26 & 0x3F)} .
$this->_base64{($int >> 20 & 0x3F)} .
$this->_base64{($int >> 14 & 0x3F)} .
$this->_base64{($int >> 8 & 0x3F)} .
$this->_base64{($int >> 2 & 0x3F)} .
$this->_base64{($int << 4 & 0x3F)} . "==";
}

//strict 32 bit addition using logic
protected function binadd($val1 , $val2)
{
$tc = $val1 & $val2;
$ta = $val1 ^ $val2;
do{
$tac = ($tc << 1) & 0x0FFFFFFFF;
$tc = $ta & $tac;
$ta = $ta ^ $tac;
}while($tc);
return $ta; // $ta will now be the result so return it
}

// Convers any string to a 32 char MD5 string and then to a list of
// 4 * 32 bit integers = 128 bit Key.
protected function xtea_key_from_string( $str )
{
$str = md5($str . ":0"); // Use nonce = 0 in LSL for same output
eval("\$this->_xtea_key[0] = 0x" . substr($str,0,8) . ";");
eval("\$this->_xtea_key[1] = 0x" . substr($str,8,8) . ";");
eval("\$this->_xtea_key[2] = 0x" . substr($str,16,8) . ";");
eval("\$this->_xtea_key[3] = 0x" . substr($str,24,8) . ";");
}

// Encipher two integers and return the result as a 12-byte string
// containing two base64-encoded integers.
protected function xtea_encipher( $v0 , $v1 )
{
$num_rounds = $this->_xtea_num_rounds;
$sum = 0;
do {
// LSL only has 32 bit integers. However PHP automaticly changes
// 32 bit integers to 64 bit floats as nessesary. This causes
// incompatibilities between the LSL Encryption and the PHP
// counterpart. I got round this by changing all addition to
// binary addition using logical & and ^ and loops to handle bit
// carries. This forces the 32 bit integer to remain 32 bits as
// I mask out any carry over 32 bits. this bring the output of the
// encrypt routine to conform with the output of its LSL counterpart.

// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.

// calculate ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
$v0a = $this->binadd((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) , $v1);
// calculate ($sum + $this->_xtea_key[$sum & 3])
$v0b = $this->binadd($sum , $this->_xtea_key[$sum & 3]);
// Calculate ($v0 + ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
// ^ ($sum + $this->_xtea_key[$sum & 3]))
$v0 = $this->binadd($v0 , ($v0a ^ $v0b));

//Calculate ($sum + $this->_XTEA_DELTA)
$sum = $this->binadd($sum , $this->_XTEA_DELTA);

//Calculate ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
$v1a = $this->binadd((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) , $v0);
// Calculate ($sum + $this->_xtea_key[($sum >>11) & 3])
$v1b = $this->binadd($sum , $this->_xtea_key[($sum >>11) & 3]);
//Calculate ($v1 + ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0
// ^ ($sum & $this->_xtea_key[($sum >>11) & 3]))
$v1 = $this->binadd($v1 , ($v1a ^ $v1b));
} while( $num_rounds = ~-$num_rounds );
//return only first 6 chars to remove "=="'s and compact encrypted text.
return substr($this->integer_base64($v0),0,6) . substr($this->integer_base64($v1),0,6);
}

// Decipher two base64-encoded integers and return the FIRST 30 BITS of
// each as one 10-byte base64-encoded string.
protected function xtea_decipher( $v0, $v1 )
{
$num_rounds = $this->_xtea_num_rounds;
$sum = 0; // $this->_XTEA_DELTA * $this->_xtea_num_rounds;
$tda = $this->_XTEA_DELTA;
do{ // Binary multiplication using binary manipulation
if($num_rounds & 1){
$sum = $this->binadd($sum , $tda);
}
$num_rounds = $num_rounds >> 1;
$tda = ($tda << 1) & 0x0FFFFFFFF;
}while($num_rounds);
$num_rounds = $this->_xtea_num_rounds; // reset $num_rounds back to its propper setting;

do {
// LSL only has 32 bit integers. However PHP automaticly changes
// 32 bit integers to 64 bit floats as nessesary. This causes
// incompatibilities between the LSL Encryption and the PHP
// counterpart. I got round this by changing all addition to
// binary addition using logical & and ^ and loops to handle bit
// carries. This forces the 32 bit integer to remain 32 bits as
// I mask out any carry over 32 bits. this bring the output of the
// decrypt routine to conform with the output of its LSL counterpart.
// Subtrations are handled by using 2's compliment

// LSL does not have unsigned integers, so when shifting right we
// have to mask out sign-extension bits.

// calculate ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
$v1a = $this->binadd((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) , $v0);
// calculate ($sum + $this->_xtea_key[($sum>>11) & 3])
$v1b = $this->binadd($sum , $this->_xtea_key[($sum>>11) & 3]);
//Calculate 2's compliment of ($v1a ^ $v1b) for subtraction
$v1c = $this->binadd((~($v1a ^ $v1b)) , 1);
//Calculate ($v1 - ((($v0 << 4) ^ (($v0 >> 5) & 0x07FFFFFF)) + $v0)
// ^ ($sum + $this->_xtea_key[($sum>>11) & 3]))
$v1 = $this->binadd($v1 , $v1c);

// Calculate new $sum based on $num_rounds - 1
$tnr = $num_rounds - 1; // Temp $num_rounds
$sum = 0; // $this->_XTEA_DELTA * ($num_rounds - 1);
$tda = $this->_XTEA_DELTA;
do{ // Binary multiplication using binary manipulation
if($tnr & 1){
$sum = $this->binadd($sum , $tda);
}
$tnr = $tnr >> 1;
$tda = ($tda << 1) & 0x0FFFFFFFF;
}while($tnr);

//Calculate ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1)
$v0a = $this->binadd((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) , $v1);
//Calculate ($sum + $this->_xtea_key[$sum & 3])
$v0b = $this->binadd($sum , $this->_xtea_key[$sum & 3]);
//Calculate 2's compliment of ($v0a ^ $v0b) for subtraction
$v0c = $this->binadd((~($v0a ^ $v0b)) , 1);
//Calculate ($v0 - ((($v1 << 4) ^ (($v1 >> 5) & 0x07FFFFFF)) + $v1
// ^ ($sum + $this->_xtea_key[$sum & 3]))
$v0 = $this->binadd($v0 , $v0c);
} while ( $num_rounds = ~-$num_rounds );

return substr($this->integer_base64($v0), 0, 5) . substr($this->integer_base64($v1), 0, 5);
}

}

?>
</php>

= Test Vectors =
These are test vectors to verify that the implementation is working correctly. Although the LSL implementation is for six rounds only, it can easily be changed to verify that the implementation is working as expected. Having a proper implementation allows other systems to communicate using the LSL implementation of XTEA.

==Bouncy Castle C# API==
These test vectors are taken from [http://www.bouncycastle.org/csharp/ The Bouncy Castle C# API].

{|{{Prettytable}}
|-{{Hl2}}
! Rounds
! Data
! Key
! Vector
|-
| 32
| {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}}
| {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}}
| {{LSL Hex|0xDEE9D4D8|}} {{LSL Hex|0xF7131ED9|}}

|-
| 32
| {{LSL Hex|0x01020304|}} {{LSL Hex|0x05060708|}}
| {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}}
| {{LSL Hex|0x065C1B89|}} {{LSL Hex|0x75C6A816|}}
|-
| 32
| {{LSL Hex|0x00000000|}} {{LSL Hex|0x00000000|}}
| {{LSL Hex|0x01234567|}} {{LSL Hex|0x12345678|}} {{LSL Hex|0x23456789|}} {{LSL Hex|0x3456789A|}}
| {{LSL Hex|0x1FF9A026|}} {{LSL Hex|0x1AC64264|}}
|-
| 32
| {{LSL Hex|0x01020304|}} {{LSL Hex|0x05060708|}}
| {{LSL Hex|0x01234567|}} {{LSL Hex|0x12345678|}} {{LSL Hex|0x23456789|}} {{LSL Hex|0x3456789A|}}
| {{LSL Hex|0x8C67155B|}} {{LSL Hex|0x2EF91EAD|}}
|}

==Test Vectors for TEA and XTEA==
These test vectors used are from [http://www.cix.co.uk/~klockstone/teavect.htm Test Vectors for TEA and XTEA].
They are made by starting with a vector of 6 zeroes, data followed by key, and coding with one cycle then moving the six cyclically so that n becomes n-1 modulo 6.

{|{{Prettytable}}
|-{{Hl2}}
! Round
!colspan="6"|vector
|-
| 1
||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x9E3779B9|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}
|-
| 2
||{{LSL Hex|0xEC01A1DE|}}||{{LSL Hex|0xAAA0256D|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}
|-
| 4
||{{LSL Hex|0xBC3A7DE2|}}||{{LSL Hex|0x4E238EB9|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0x00000000|}}||{{LSL Hex|0xEC01A1DE|}}||{{LSL Hex|0x114F6D74|}}
|-
| 8
||{{LSL Hex|0x31C5FA6C|}}||{{LSL Hex|0x241756D6|}}||{{LSL Hex|0xBC3A7DE2|}}||{{LSL Hex|0x845846CF|}}||{{LSL Hex|0x2794A127|}}||{{LSL Hex|0x6B8EA8B8|}}
|-
| 16
||{{LSL Hex|0x1D8E6992|}}||{{LSL Hex|0x9A478905|}}||{{LSL Hex|0x6A1D78C8|}}||{{LSL Hex|0x08C86D67|}}||{{LSL Hex|0x2A65BFBE|}}||{{LSL Hex|0xB4BD6E46|}}
|-
| 32
||{{LSL Hex|0xD26428AF|}}||{{LSL Hex|0x0A202283|}}||{{LSL Hex|0x27F917B1|}}||{{LSL Hex|0xC1DA8993|}}||{{LSL Hex|0x60E2ACAA|}}||{{LSL Hex|0xA6EB923D|}}
|-
| 64
||{{LSL Hex|0x7A01CBC9|}}||{{LSL Hex|0xB03D6068|}}||{{LSL Hex|0x62EE209F|}}||{{LSL Hex|0x069B7AFC|}}||{{LSL Hex|0x376A8936|}}||{{LSL Hex|0xCDC9E923|}}
|}

==LSL Test==
The following code has been imported to LSL to test the vectors with an XTEA implementation. It also makes use of a modified version of the [[Hex]] method on this wiki to display the data. Right Shift of signed integers is handed by techniques introduced in the [[Right_Shift]] method on this wiki.

<lsl>
// XTEA is a version of slightly improved TEA
// The plain or cypher text is in v[0], v[1]
// The key is in k[n], where n = 0 - 3
// The number of coding cycles is given by N and
// the number of decoding cycles is given by -N

list XTEA(list v, list k, integer N) // Replaces TEA's Code and Decode
{
integer y = llList2Integer(v, 0);
integer z = llList2Integer(v, 1);
integer DELTA = 0x9E3779B9;
integer limit = DELTA * N;
integer sum = 0;

if(N > 0) // encrypt
{
while(sum != limit)
{
y += (z << 4 ^ ((z >> 5) & 0x07FFFFFF)) + z ^ sum + llList2Integer(k, sum & 3);
sum += DELTA;
z += (y << 4 ^ ((y >> 5) & 0x07FFFFFF)) + y ^ sum + llList2Integer(k, (sum >> 11) & 3);
}
}
else // decrypt
{
for(sum = -limit; sum; )
{ z -= (y << 4 ^ ((y >> 5) & 0x07FFFFFF)) + y ^ sum + llList2Integer(k, (sum >> 11) & 3);
sum -= DELTA;
y -= (z << 4 ^ ((z >> 5) & 0x07FFFFFF)) + z ^ sum + llList2Integer(k, sum & 3);
}
}

return [y,z];
}
string hex(integer value)
{
string h = "";
while (value)
{
string c = llGetSubString("0123456789ABCDEF", value & 0xF, value & 0xF);
h = c + h;
value = (value >> 4) & 0x0FFFFFFF;
}
return "0x" + llGetSubString("00000000" + h, -8, -1);
}
default
{
state_entry()
{

// Bouncy Castle C# API Test Vectors
list v;
v = XTEA([0x00000000, 0x00000000], [0x00000000, 0x00000000, 0x00000000, 0x00000000], 32);
llSay(DEBUG_CHANNEL, hex(llList2Integer(v, 0)) + "\t" + hex(llList2Integer(v, 1)) + "\texpected\t0xDEE9D4D8\t0xF7131ED9");

v = XTEA([0x01020304, 0x05060708], [0x00000000, 0x00000000, 0x00000000, 0x00000000], 32);
llSay(DEBUG_CHANNEL, hex(llList2Integer(v, 0)) + "\t" + hex(llList2Integer(v, 1)) + "\texpected\t0x065C1B89\t0x75C6A816");

v = XTEA([0x00000000, 0x00000000], [0x01234567, 0x12345678, 0x23456789, 0x3456789A], 32);
llSay(DEBUG_CHANNEL, hex(llList2Integer(v, 0)) + "\t" + hex(llList2Integer(v, 1)) + "\texpected\t0x1FF9A026\t0x1AC64264");

v = XTEA([0x01020304, 0x05060708], [0x01234567, 0x12345678, 0x23456789, 0x3456789A], 32);
llSay(DEBUG_CHANNEL, hex(llList2Integer(v, 0)) + "\t" + hex(llList2Integer(v, 1)) + "\texpected\t0x8C67155B\t0x2EF91EAD");

// Test Vectors for XTEA

list pz = [0,0,0,0,0,0,0];
integer n;
for (n = 1; n < 65; n++)
{

list a = XTEA(llList2List(pz, n, n + 1), llList2List(pz, n + 2, n + 5), n);

pz = llListReplaceList(pz, a, n, n + 1);

if (n == (n & -n)) // if n power of 2
llSay(DEBUG_CHANNEL,
(string)n
+ "\t" + hex(llList2Integer(pz, n + 0))
+ "\t" + hex(llList2Integer(pz, n + 1))
+ "\t" + hex(llList2Integer(pz, n + 2))
+ "\t" + hex(llList2Integer(pz, n + 3))
+ "\t" + hex(llList2Integer(pz, n + 4))
+ "\t" + hex(llList2Integer(pz, n + 5))
);
pz = llListReplaceList(pz, llList2List(pz, n, n + 5), n + 6, n + 11);
}
}
}
</lsl>

{{#vardefine:sort|XTEA Strong Encryption Implementation}}{{LSLC|Library}}{{LSLC|Examples}}
[[Category:LSL Encryption]]

ZZText

2010-03-09T09:36:46Z

New Spore:

== What is it ==

Scripting tools to allow display of text on a prim: [[XyText 1.5]] (aka XyText) , [[XyzzyText]], [[XyyyyzText]], [[XyzzyText-UTF8]], [[ZZText]]

'''ZZText''' is a low-prim, low-lag, international variation of [[XyText]] with the following features:
* can be enhanced with new fonts or UTF-8 characters using GIMP and python-fu.
* uses only 35 textures instead of 66 for the 10 chars on prim solution (this gives a bit less quality then the original xytext, but under normal situations is acceptable.

Rationale: if you have problems with prim usage, then you can accept this compromise.

* this particular combination of textures gives something way more rapid than [[XyzzyText]], which is very slow for big boards, and less lagger than [[XyText]].
* small warning: there is still some slight improvements for this zzText to be reasonably acceptable (consider it in a Beta stage), will post soon when it will be fully acceptable.

== Credits and copyright ==
ZZText is heavily dependent on [[XyText]] so it shares and extends credits and copyrights.

Also this is a low prim variation of the [[XyzzyText-UTF8]] page but downgraded to use XyText lower quality paradigm instead than the 1 character face approach.

== How to generate the textures ==

* You need to have GIMP 2.0 with python-fu extension installed
**Here the instructions on windows to do that:
** Install python 2.6.2 from http://www.python.org/download/,
** '''RESTART the PC!!'''
** Install gtk+ run time environment from: http://sourceforge.net/project/showfiles.php?group_id=71914
** '''''Install python extensions to graphic libs. Be sure to choose the 2.6.2 python compatibility'''''
*** Install pycairo from http://ftp.gnome.org/pub/GNOME/binaries/win32/pycairo/
*** Install pygobject from http://ftp.gnome.org/pub/GNOME/binaries/win32/pygobject/
*** Install pygtk from http://ftp.acc.umu.se/pub/GNOME/binaries/win32/pygtk/
** '''RESTART the PC!!'''
** Install gimp 2.6.6 from http://gimp.org/
** '''''Verify launching gimp, filters, python-fu, console to see Python 2.6.2'''''
* Use the mega-image maker python-fu script (see following sections)
* Use the splitter python-fu script to produce 512x512 guides for later splitting
* Use the filter/web/slice... button to produce 64 slices in png format to retain transparence (from 0-0 to 7-7)
* Manually remove the empty slices (the i-j where j>i for instance 2-3, 6-7) so you have only 35 images png.
* Manually convert each png to tga (this is solving some problems with sl uploading regarding transparence)
* Upload the textures keeping the order 0-0 1-0 1-1 2-0 2-1 2-3 .... until 7-7)

Manual parts can be automated by another python-fu, but I was so exhausted with the others that it was ok for me doing manually :)

There is still some fix needed to do on the python-fu script. Currently characters are still a bit unevenly put so that when displaying them
depending on which couple using we might see some slight asymmetric unbalancing. You can note this only when looking very closely to the chars.
Whenever I fix myself this problem I will post here.

For those of you who already accept fonts I did last week, look at next sections for the 35 texture UUIDs:

== So how can I use it? ==

* Put the script named ZZText into each prim of your board naming each cell 1000 ---- 1099 as far as you need cells
* Have a main script doing the following: llMessageLinked(LINK_SET,1040,"çòàùè",NULL_KEY) to write on cell named 1040

To divide in rows, use simple modulus operations.

== Variation on [[XyText 1.5]] standard script ==

For not being so difficult to follow, I only publish differences between my script and [[XyText 1.5]] so that you might be able to understand better what I did:
=== Change CHARACTER_GRID with our full permission textures ===
<lsl>
list CHARACTER_GRID = [
"96f4578b-879e-44ae-d223-427cc615f5a4", // my slice-0-0
"eab5360f-6653-593f-b679-69c68b0dd001", // 1-0
"367330be-717a-277d-5205-131cd6ded458", // 1-1
"32046675-6e7e-2425-ce77-69000b0b4d96", // 2-0
"40085901-bde6-2dd4-40cd-b6d48d242997", // 2-1
"205d318b-09b7-7ecc-922e-801c93a546c8", // 2-2
"841e7826-3645-d4f0-d48b-389586dd8e90", // 3-0
"e2db78c5-fb47-d767-4744-8cb6d84610d0", // 3-1
"15312c89-afd4-854c-9d9b-5b9e11844aed", // 3-2
"d180e771-0393-d09b-8cac-0af6d550ae4a", // 3-3
"c6c1d2c8-5dfd-b13a-7f1e-c3ede8126769", // 4-0
"bc100d0c-a445-947f-caa4-285d9cc8a9de", // 4-1
"0b31e862-75a4-9ed3-6331-e9e700a0fedb", // 4-2
"0eacc306-6bd5-ab31-de47-c686141a6733", // 4-3
"b68de1d9-4890-74a0-4d25-d4d5c83a0dba", // 4-4
"04b2bf9b-a8bb-0a39-1062-9b005229eba9", // 5-0
"be293f10-25ec-beb9-738b-fe1892b82aef", // 5-1
"5e9c8317-71f5-f073-76ab-7c412d3acb84", // 5-2
"030b441b-9022-2aba-f7a7-af6810c354b8", // 5-3
"9f455858-8ae6-3a9a-c2d4-bc5ee92430ac", // 5-4
"ee741143-f01e-f730-667e-66a3cd57d1cc", // 5-5
"710282bc-bd80-5a44-6987-0c4c11a4c294", // 6-0
"c9c410db-675a-1e98-4107-debd3c73a754", // 6-1
"486c2336-71c5-b962-266c-838a865c067c", // 6-2
"d4722155-0b6d-3673-0208-a727729bc117", // 6-3
"bc7af3cd-ee48-08df-fe8b-a6ca8a425733", // 6-4
"f23d7a73-00c3-1ffd-69a7-0cca031c939d", // 6-5
"aa95bfd1-ac80-f962-7acf-d6aeed9c7e81", // 6-6
"53fd52e3-0e8b-dcc8-42f8-332aef421bd2", // 7-0
"da3f6f09-3e3a-e156-8e2e-1040111a5635", // 7-1
"409a95c0-b685-2036-d0de-75e8ab654243", // 7-2
"14e05aca-3a61-b892-3632-dcde72324779", // 7-3
"546c0e4f-b678-895d-2035-0f39bb7f4979", // 7-4
"cf2fc337-109f-ba25-8ff5-786f7d6ceb5b", // 7-5
"9943204b-a4de-868a-3cdd-8785d1864ede", // 7-6
"765cfd9c-9703-b5ba-2c5d-f1c8bd44e0f4" // 7-7
];

</lsl>

=== Enabling answering to only a specific channel instead of DISPLAY_STRING channel ===
This heavily helps in producing multi cell boards:
<lsl>
integer ME;
....
state_entry(){
....
ME=(integer)llGetObjectName(); // need that each cell has its own number as object name starting from 1000 for instance
....
// be sure we are answering only to channel ME
link_message(integer sender, integer channel, string data, key id) {
if (channel == (ME) {
RenderString(data);
return;
}
</lsl>

=== UTF-8 character specification ===
This must closely match what you produced with python-fu
<lsl>
ResetCharIndex() {
gCharIndex = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`";
// \" <-- Fixes LSL syntax highlighting bug.
gCharIndex += "abcdefghijklmnopqrstuvwxyz{|}~";
// cap cedille u: e/ a^ a: a/ a ring cedille e^ e:
decode= ["%C3%87", "%C3%BC", "%C3%A9", "%C3%A2", "%C3%A4", "%C3%A0", "%C3%A5", "%C3%A7", "%C3%AA", "%C3%AB",

// e\ i: i^ i\ A: A ring E/ ae AE marker >
"%C3%A8", "%C3%AF", "%C3%AE", "%C3%AC", "%C3%84", "%C3%85", "%C3%89", "%C3%A6", "%C3%86", "%E2%96%B6" ,

// o: o/ u^ u\ y: O: U: cent pound yen
"%C3%B6", "%C3%B2", "%C3%BB", "%C3%B9", "%C3%BF", "%C3%96", "%C3%9C", "%C2%A2", "%C2%A3", "%C2%A5",

// A^ a/ i/ o/ u/ n~ E: y/ inv ? O^
"%C3%82", "%C3%A1", "%C3%AD", "%C3%B3", "%C3%BA", "%C3%B1", "%C3%8B", "%C3%BD", "%C2%BF", "%C3%94",

// inv ! I\ I/ degree E^ I^ o^ U^
"%C2%A1", "%C3%8C", "%C3%8D", "%C2%B0", "%C3%8A", "%C3%8E", "%C3%B4", "%C3%9B",

// Y: euro german ss E\ A\ A/ U\ U/ O\ O/
"%C3%9D", "%E2%82%AC", "%C3%9F", "%C3%88", "%C3%80", "%C3%81", "%C3%99", "%C3%9A", "%C3%92", "%C3%93",

// Sv sv zv Zv Y: I:
"%C5%A0", "%C5%A1", "%C5%BE", "%C5%BD", "%C3%9D", "%C3%8C" ];

}
</lsl>

=== Accessing the new characters from textures ===
This is the most difficult part. Still need to clean up offsets, since now they are still a bit wrong.

<lsl>
vector GetGridOffset(vector grid_pos) {
// Zoom in on the texture showing our character pair.
integer Col = llRound(grid_pos.x) % 40; // PK was 20
integer Row = llRound(grid_pos.y) % 20; // PK was 10

// Return the offset in the texture.
return <-0.45 + 0.025 * Col, 0.45 - 0.05 * Row, 0.0>; // PK was 0.05 and 0.1
}

ShowChars(vector grid_pos1, vector grid_pos2, vector grid_pos3, vector grid_pos4, vector grid_pos5) {
// Set the primitive textures directly.

llSetPrimitiveParams( [
PRIM_TEXTURE, FACE_1, GetGridTexture(grid_pos1), <0.125, 0.05, 0>, GetGridOffset(grid_pos1) + <0.0375-0.025-0.002, 0.025, 0>, 0.0,
PRIM_TEXTURE, FACE_2, GetGridTexture(grid_pos2), <0.05, 0.05, 0>, GetGridOffset(grid_pos2)+<-0.025-0.002, 0.025,0>, 0.0,
PRIM_TEXTURE, FACE_3, GetGridTexture(grid_pos3), <-0.74, 0.05, 0>, GetGridOffset(grid_pos3)+ <-.34-0.002, 0.025, 0>, 0.0,
PRIM_TEXTURE, FACE_4, GetGridTexture(grid_pos4), <0.05, 0.05, 0>, GetGridOffset(grid_pos4)+<-0.025-0.002, 0.025,0>, 0.0,
PRIM_TEXTURE, FACE_5, GetGridTexture(grid_pos5), <0.125, 0.05, 0>, GetGridOffset(grid_pos5) + <0.0375-0.025-0.077-0.002, 0.025, 0>, 0.0
// PRIM_TEXTURE, FACE_1, GetGridTexture(grid_pos1), <0.25, 0.1, 0>, GetGridOffset(grid_pos1) + <0.075, 0, 0>, 0.0,
// PRIM_TEXTURE, FACE_2, GetGridTexture(grid_pos2), <0.1, 0.1, 0>, GetGridOffset(grid_pos2), 0.0,
// PRIM_TEXTURE, FACE_3, GetGridTexture(grid_pos3), <-1.48, 0.1, 0>, GetGridOffset(grid_pos3)+ <0.37, 0, 0>, 0.0,
// PRIM_TEXTURE, FACE_4, GetGridTexture(grid_pos4), <0.1, 0.1, 0>, GetGridOffset(grid_pos4), 0.0,
// PRIM_TEXTURE, FACE_5, GetGridTexture(grid_pos5), <0.25, 0.1, 0>, GetGridOffset(grid_pos5) - <0.075, 0, 0>, 0.0

]);
}

integer GetIndex(string char)
{
integer ret=llSubStringIndex(gCharIndex, char);
if(ret>=0) return ret;

// special char do nice trick :)
string escaped=llEscapeURL(char);

if(escaped=="%E2%80%99") return 7; // remap ’
//llSay(0,"Looking for "+escaped);
integer found=llListFindList(decode, [escaped]);

// not found
if(found<0) return 0;

// return correct index
return llStringLength(gCharIndex)+found;

}

RenderString(string str) {
// Get the grid positions for each pair of characters.
vector GridPos1 = GetGridPos( GetIndex(llGetSubString(str, 0, 0)),
GetIndex(llGetSubString(str, 1, 1)) );
vector GridPos2 = GetGridPos( GetIndex(llGetSubString(str, 2, 2)),
GetIndex(llGetSubString(str, 3, 3)) );
vector GridPos3 = GetGridPos( GetIndex(llGetSubString(str, 4, 4)),
GetIndex(llGetSubString(str, 5, 5)) );
vector GridPos4 = GetGridPos( GetIndex(llGetSubString(str, 6, 6)),
GetIndex(llGetSubString(str, 7, 7)) );
vector GridPos5 = GetGridPos( GetIndex(llGetSubString(str, 8, 8)),
GetIndex(llGetSubString(str, 9, 9)) );

// Use these grid positions to display the correct textures/offsets.
ShowChars(GridPos1, GridPos2, GridPos3, GridPos4, GridPos5);
}

</lsl>

== Splitter python-fu script ==
You need to put this under the %USERPROFILE%\.gimp-2.6\plug-ins folder (in my case: \Documents and Settings\salahzar.SALAHZAR-PC\.gimp-2.6\plug-ins).

To avoid problems with indents, spaces and tabs create the file with explorer guides.py and right clich use the IDLE edit to past the following source.

Note: you need to restart GIMP to see it working.

When running it is very simple just tell it "512" to split every 512 points.
<python>
#!/usr/bin/env python

import math
from gimpfu import *

def python_guides(timg, tdrawable, interval=100):
timg.undo_group_start()
for x in range(0, timg.width, interval):
timg.add_vguide(x)

for y in range(0, timg.height, interval):
timg.add_hguide(y)

timg.undo_group_end()

gimp.displays_flush()

register(
"python_fu_guides",
"Guides: this will split the images in sections...",
"Guides: this will split the images in sections...",
"Salahzar Stenvaag",
" ",
"2008",
"<Image>/Filters/Guides...",
"RGB*, GRAY*",
[
(PF_INT, "interval", "Interval", 100)
],
[],
python_guides)

main()

</python>

If the guides.py script is correctly installed you will see the following:

[[Image:XyText-utf8-Guides.jpg]]

Options to choose:

[[Image:XyText-UTF8-Guides2.jpg]]

And the image with the lines in blue:

[[Image:XyText-UTF8-Guides3.jpg]]

== Mega-image maker python-fu script ==
You need to put this under the %USERPROFILE%\.gimp-2.6\plug-ins folder (in my case: \Documents and Settings\salahzar.SALAHZAR-PC\.gimp-2.6\plug-ins).

To avoid problems with indents, spaces and tabs create the file with explorer megaimages.py and right clich use the IDLE edit to past the following source.

If you need your characters you need to change the UTF-8 codings in "decode" var

<python>
#! /usr/bin/env python
from gimpfu import *

# you can remove logging, I used it to be sure program was working since it can be a bit slow
# to generate all the combination
def python_log_init():
fileHandle = open( 'python.log', 'w')
fileHandle.close()

def python_log(s):
fileHandle = open ( 'python.log', 'a' )
fileHandle.write(str(s)+"\n")
fileHandle.close()

def python_xytext2(font,color,size,limit):
"""Print the arguments on standard output"""
python_log_init()
python_log("font: %s color: <%d,%d,%d> size: %d limit: %d" % ( font, color[0], color[1], color[2], size, limit ))
chars = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"

#

# cap cedille u: e/ a^ a: a/ a ring cedille e^ e:
decode= ["\xC3\x87", "\xC3\xBC", "\xC3\xA9", "\xC3\xA2", "\xC3\xA4", "\xC3\xA0", "\xC3\xA5", "\xC3\xA7", "\xC3\xAA", "\xC3\xAB" ]

# e\ i: i^ i\ A: A ring E/ ae AE marker >
decode+=["\xC3\xA8", "\xC3\xAF", "\xC3\xAE", "\xC3\xAC", "\xC3\x84", "\xC3\x85", "\xC3\x89", "\xC3\xA6", "\xC3\x86", "\xE2\x96\xB6" ]

# o: o/ u^ u\ y: O: U: cent pound yen
decode+=["\xC3\xB6", "\xC3\xB2", "\xC3\xBB", "\xC3\xB9", "\xC3\xBF", "\xC3\x96", "\xC3\x9C", "\xC2\xA2", "\xC2\xA3", "\xC2\xA5"]

# A^ a/ i/ o/ u/ n~ E: y/ inv ? O^
decode+=["\xC3\x82", "\xC3\xA1", "\xC3\xAD", "\xC3\xB3", "\xC3\xBA", "\xC3\xB1", "\xC3\x8B", "\xC3\xBD", "\xC2\xBF", "\xC3\x94" ]

# inv ! I\ I/ degree E^ I^ o^ U^
decode+=["\xC2\xA1", "\xC3\x8C", "\xC3\x8D", "\xC2\xB0", "\xC3\x8A", "\xC3\x8E", "\xC3\xB4", "\xC3\x9B" ]

# Y: euro german ss E\ A\ A/ U\ U/ O\ O/
decode+=["\xC3\x9D", "\xE2\x82\xAC", "\xC3\x9F", "\xC3\x88", "\xC3\x80", "\xC3\x81", "\xC3\x99", "\xC3\x9A", "\xC3\x92", "\xC3\x93" ]

# Sv sv zv Zv Y: I:
decode+=[ "\xC5\xA0", "\xC5\xA1", "\xC5\xBE", "\xC5\xBD", "\xC3\x9D", "\xC3\x8C" ]

width=5120
height=5120
img = gimp.Image(width, height, RGB)
layer = gimp.Layer(img, "my font", width, height, RGB_IMAGE, 100, NORMAL_MODE)
img.add_layer(layer, 0)
layer.add_alpha()
gimp.set_foreground(color)
pdb.gimp_selection_all(img)
pdb.gimp_edit_clear(layer)
pdb.gimp_selection_none(img)
size= 20 # 23 # 21.3 # 30

index=0
numtot=len(chars)+len(decode)
#numtot=50
if limit>0: numtot=limit
deltay=12.8 # 13.8215 # 12.8 # 18
deltax=25.6 # 27.6432 # 25.6 # 36
maxchars=len(chars)
for first in range(numtot):

if first<maxchars:
el1=chars[first]
else:
el1=decode[first-maxchars]

python_log(str(first)+"/"+str(numtot)+": "+el1)
for second in range(first+1):

# to save time removed function call
if second<maxchars:
el2=chars[second]
else:
el2=decode[second-maxchars]

y=second * deltay * 2 # horizontal distance
x=first*deltax # line distance
pdb.gimp_text_fontname(img,layer,y,x,el1,0,TRUE,size,PIXELS,font)
pdb.gimp_text_fontname(img,layer,y+deltay,x,el2,0,TRUE,size,PIXELS,font)

index+=1

# Now ready to display this image
img.merge_visible_layers(0)
gimp.Display(img)

register(
"xytext2", "", "", "", "", "",
"<Toolbox>/Xtns/_MegaImage", "",
[
(PF_FONT, "font", "Font to use", "Arial"),
(PF_COLOR,"color","Color to use", (255,255,255) ),
(PF_INT, "size", "Font size", 45 ),
(PF_INT, "limit", "limit font generation ", 0 ),

],
[],
python_xytext2
)

main()
</python>

Here how the menu should appear:

[[Image:XyText-UTF8-Megaimagechoose.jpg]]

How to launch it: '''Note!! DON'T USE PROPORTIONAL CHARACTERS!!! BUT MONOSPACE 43 MIGHT BE BETTER'''
Also when checking use the limit font generation to 10: the computing process for all 200 characters is VEEERY LOOONG!!!! 0 means all the characters.

[[Image:XyText-UTF8-Megaimage2.jpg]]

How to zoom on the megaimage (Zoom 100%) and check produced characters:

[[Image:XyText-UTF8-Zoom11.jpg]]

As you see the default is producing BAD characters.. Proportional cannot be used since characters cannot be computed with xytext optimized algorithm.

[[Image:XyText-UTF8-Zoom2.jpg]]

== What if I want the full script? ==
Here you are:
<lsl>
////////////////////////////////////////////
// ZZText (5 Face, Multi Texture)
//
// Originally Written by Xylor Baysklef
//
// Modified by Thraxis Epsilon January 20, 2006
// Added Support for 5 Face Prim, based on modification
// of XyText v1.1.1 by Kermitt Quick for Single Texture.
//
// Modified by Salahzar Stenvaag for International and new textures
// produced with GIMP. See wiki page ZZText for further info
// Obtain ME (starting linking channel from Object name)
// thane can use all the other commands
// IDEAL for linked structures
////////////////////////////////////////////

/////////////// CONSTANTS ///////////////////
// XyText Message Map.
integer DISPLAY_STRING = 0;
integer DISPLAY_EXTENDED = 100;
integer REMAP_INDICES = 200;
integer RESET_INDICES = 300;
integer SET_CELL_INFO = 400;
integer SET_THICKNESS = 600;
integer SET_COLOR = 700;

// This is an extended character escape sequence.
string ESCAPE_SEQUENCE = "\\e";

// This is used to get an index for the extended character.
string EXTENDED_INDEX = "123456789abcdef";

// Face numbers.
integer FACE_1 = 3;
integer FACE_2 = 7;
integer FACE_3 = 4;
integer FACE_4 = 6;
integer FACE_5 = 1;

list decode=[]; // to handle special characters from CP850 page for european countries

// Used to hide the text after a fade-out.
key TRANSPARENT = "701917a8-d614-471f-13dd-5f4644e36e3c";
// This is a list of textures for all 2-character combinations.
list CHARACTER_GRID = [
"96f4578b-879e-44ae-d223-427cc615f5a4", // my slice-0-0
"eab5360f-6653-593f-b679-69c68b0dd001", // 1-0
"367330be-717a-277d-5205-131cd6ded458", // 1-1
"32046675-6e7e-2425-ce77-69000b0b4d96", // 2-0
"40085901-bde6-2dd4-40cd-b6d48d242997", // 2-1
"205d318b-09b7-7ecc-922e-801c93a546c8", // 2-2
"841e7826-3645-d4f0-d48b-389586dd8e90", // 3-0
"e2db78c5-fb47-d767-4744-8cb6d84610d0", // 3-1
"15312c89-afd4-854c-9d9b-5b9e11844aed", // 3-2
"d180e771-0393-d09b-8cac-0af6d550ae4a", // 3-3
"c6c1d2c8-5dfd-b13a-7f1e-c3ede8126769", // 4-0
"bc100d0c-a445-947f-caa4-285d9cc8a9de", // 4-1
"0b31e862-75a4-9ed3-6331-e9e700a0fedb", // 4-2
"0eacc306-6bd5-ab31-de47-c686141a6733", // 4-3
"b68de1d9-4890-74a0-4d25-d4d5c83a0dba", // 4-4
"04b2bf9b-a8bb-0a39-1062-9b005229eba9", // 5-0
"be293f10-25ec-beb9-738b-fe1892b82aef", // 5-1
"5e9c8317-71f5-f073-76ab-7c412d3acb84", // 5-2
"030b441b-9022-2aba-f7a7-af6810c354b8", // 5-3
"9f455858-8ae6-3a9a-c2d4-bc5ee92430ac", // 5-4
"ee741143-f01e-f730-667e-66a3cd57d1cc", // 5-5
"710282bc-bd80-5a44-6987-0c4c11a4c294", // 6-0
"c9c410db-675a-1e98-4107-debd3c73a754", // 6-1
"486c2336-71c5-b962-266c-838a865c067c", // 6-2
"d4722155-0b6d-3673-0208-a727729bc117", // 6-3
"bc7af3cd-ee48-08df-fe8b-a6ca8a425733", // 6-4
"f23d7a73-00c3-1ffd-69a7-0cca031c939d", // 6-5
"aa95bfd1-ac80-f962-7acf-d6aeed9c7e81", // 6-6
"53fd52e3-0e8b-dcc8-42f8-332aef421bd2", // 7-0
"da3f6f09-3e3a-e156-8e2e-1040111a5635", // 7-1
"409a95c0-b685-2036-d0de-75e8ab654243", // 7-2
"14e05aca-3a61-b892-3632-dcde72324779", // 7-3
"546c0e4f-b678-895d-2035-0f39bb7f4979", // 7-4
"cf2fc337-109f-ba25-8ff5-786f7d6ceb5b", // 7-5
"9943204b-a4de-868a-3cdd-8785d1864ede", // 7-6
"765cfd9c-9703-b5ba-2c5d-f1c8bd44e0f4" // 7-7
];
integer ME;
///////////// END CONSTANTS ////////////////

///////////// GLOBAL VARIABLES ///////////////
// All displayable characters. Default to ASCII order.
string gCharIndex;
// This is the channel to listen on while acting
// as a cell in a larger display.
integer gCellChannel = -1;
// This is the starting character position in the cell channel message
// to render.
integer gCellCharPosition = 0;
// This is whether or not to use the fade in/out special effect.
integer gCellUseFading = FALSE;
// This is how long to display the text before fading out (if using
// fading special effect).
// Note: < 0 means don't fade out.
float gCellHoldDelay = 1.0;
/////////// END GLOBAL VARIABLES ////////////

ResetCharIndex() {
gCharIndex = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`";
// \" <-- Fixes LSL syntax highlighting bug.
gCharIndex += "abcdefghijklmnopqrstuvwxyz{|}~";
// cap cedille u: e/ a^ a: a/ a ring cedille e^ e:
decode= ["%C3%87", "%C3%BC", "%C3%A9", "%C3%A2", "%C3%A4", "%C3%A0", "%C3%A5", "%C3%A7", "%C3%AA", "%C3%AB",

// e\ i: i^ i\ A: A ring E/ ae AE marker >
"%C3%A8", "%C3%AF", "%C3%AE", "%C3%AC", "%C3%84", "%C3%85", "%C3%89", "%C3%A6", "%C3%86", "%E2%96%B6" ,

// o: o/ u^ u\ y: O: U: cent pound yen
"%C3%B6", "%C3%B2", "%C3%BB", "%C3%B9", "%C3%BF", "%C3%96", "%C3%9C", "%C2%A2", "%C2%A3", "%C2%A5",

// A^ a/ i/ o/ u/ n~ E: y/ inv ? O^
"%C3%82", "%C3%A1", "%C3%AD", "%C3%B3", "%C3%BA", "%C3%B1", "%C3%8B", "%C3%BD", "%C2%BF", "%C3%94",

// inv ! I\ I/ degree E^ I^ o^ U^
"%C2%A1", "%C3%8C", "%C3%8D", "%C2%B0", "%C3%8A", "%C3%8E", "%C3%B4", "%C3%9B",

// Y: euro german ss E\ A\ A/ U\ U/ O\ O/
"%C3%9D", "%E2%82%AC", "%C3%9F", "%C3%88", "%C3%80", "%C3%81", "%C3%99", "%C3%9A", "%C3%92", "%C3%93",

// Sv sv zv Zv Y: I:
"%C5%A0", "%C5%A1", "%C5%BE", "%C5%BD", "%C3%9D", "%C3%8C" ];

}

vector GetGridPos(integer index1, integer index2) {
// There are two ways to use the lookup table...
integer Col;
integer Row;
if (index1 >= index2) {
// In this case, the row is the index of the first character:
Row = index1;
// And the col is the index of the second character (x2)
Col = index2 * 2;
}
else { // Index1 < Index2
// In this case, the row is the index of the second character:
Row = index2;
// And the col is the index of the first character, x2, offset by 1.
Col = index1 * 2 + 1;
}
return <Col, Row, 0>;
}

string GetGridTexture(vector grid_pos) {
// Calculate the texture in the grid to use.
integer GridCol = llRound(grid_pos.x) / 40; // PK was 20
integer GridRow = llRound(grid_pos.y) / 20; // PK was 10

// Lookup the texture.
key Texture = llList2Key(CHARACTER_GRID, GridRow * (GridRow + 1) / 2 + GridCol);
return Texture;
}

vector GetGridOffset(vector grid_pos) {
// Zoom in on the texture showing our character pair.
integer Col = llRound(grid_pos.x) % 40; // PK was 20
integer Row = llRound(grid_pos.y) % 20; // PK was 10

// Return the offset in the texture.
return <-0.45 + 0.025 * Col, 0.45 - 0.05 * Row, 0.0>; // PK was 0.05 and 0.1
}

ShowChars(vector grid_pos1, vector grid_pos2, vector grid_pos3, vector grid_pos4, vector grid_pos5) {
// Set the primitive textures directly.

llSetPrimitiveParams( [
PRIM_TEXTURE, FACE_1, GetGridTexture(grid_pos1), <0.125, 0.05, 0>, GetGridOffset(grid_pos1) + <0.0375-0.025-0.002, 0.025, 0>, 0.0,
PRIM_TEXTURE, FACE_2, GetGridTexture(grid_pos2), <0.05, 0.05, 0>, GetGridOffset(grid_pos2)+<-0.025-0.002, 0.025,0>, 0.0,
PRIM_TEXTURE, FACE_3, GetGridTexture(grid_pos3), <-0.74, 0.05, 0>, GetGridOffset(grid_pos3)+ <-.34-0.002, 0.025, 0>, 0.0,
PRIM_TEXTURE, FACE_4, GetGridTexture(grid_pos4), <0.05, 0.05, 0>, GetGridOffset(grid_pos4)+<-0.025-0.002, 0.025,0>, 0.0,
PRIM_TEXTURE, FACE_5, GetGridTexture(grid_pos5), <0.125, 0.05, 0>, GetGridOffset(grid_pos5) + <0.0375-0.025-0.077-0.002, 0.025, 0>, 0.0
// PRIM_TEXTURE, FACE_1, GetGridTexture(grid_pos1), <0.25, 0.1, 0>, GetGridOffset(grid_pos1) + <0.075, 0, 0>, 0.0,
// PRIM_TEXTURE, FACE_2, GetGridTexture(grid_pos2), <0.1, 0.1, 0>, GetGridOffset(grid_pos2), 0.0,
// PRIM_TEXTURE, FACE_3, GetGridTexture(grid_pos3), <-1.48, 0.1, 0>, GetGridOffset(grid_pos3)+ <0.37, 0, 0>, 0.0,
// PRIM_TEXTURE, FACE_4, GetGridTexture(grid_pos4), <0.1, 0.1, 0>, GetGridOffset(grid_pos4), 0.0,
// PRIM_TEXTURE, FACE_5, GetGridTexture(grid_pos5), <0.25, 0.1, 0>, GetGridOffset(grid_pos5) - <0.075, 0, 0>, 0.0

]);
}

integer GetIndex(string char)
{
integer ret=llSubStringIndex(gCharIndex, char);
if(ret>=0) return ret;

// special char do nice trick :)
string escaped=llEscapeURL(char);

if(escaped=="%E2%80%99") return 7; // remap ’
//llSay(0,"Looking for "+escaped);
integer found=llListFindList(decode, [escaped]);

// not found
if(found<0) return 0;

// return correct index
return llStringLength(gCharIndex)+found;

}

RenderString(string str) {
// Get the grid positions for each pair of characters.
vector GridPos1 = GetGridPos( GetIndex(llGetSubString(str, 0, 0)),
GetIndex(llGetSubString(str, 1, 1)) );
vector GridPos2 = GetGridPos( GetIndex(llGetSubString(str, 2, 2)),
GetIndex(llGetSubString(str, 3, 3)) );
vector GridPos3 = GetGridPos( GetIndex(llGetSubString(str, 4, 4)),
GetIndex(llGetSubString(str, 5, 5)) );
vector GridPos4 = GetGridPos( GetIndex(llGetSubString(str, 6, 6)),
GetIndex(llGetSubString(str, 7, 7)) );
vector GridPos5 = GetGridPos( GetIndex(llGetSubString(str, 8, 8)),
GetIndex(llGetSubString(str, 9, 9)) );

// Use these grid positions to display the correct textures/offsets.
ShowChars(GridPos1, GridPos2, GridPos3, GridPos4, GridPos5);
}

RenderWithEffects(string str) {
// Get the grid positions for each pair of characters.
vector GridPos1 = GetGridPos( llSubStringIndex(gCharIndex, llGetSubString(str, 0, 0)),
llSubStringIndex(gCharIndex, llGetSubString(str, 1, 1)) );
vector GridPos2 = GetGridPos( llSubStringIndex(gCharIndex, llGetSubString(str, 2, 2)),
llSubStringIndex(gCharIndex, llGetSubString(str, 3, 3)) );
vector GridPos3 = GetGridPos( llSubStringIndex(gCharIndex, llGetSubString(str, 4, 4)),
llSubStringIndex(gCharIndex, llGetSubString(str, 5, 5)) );
vector GridPos4 = GetGridPos( llSubStringIndex(gCharIndex, llGetSubString(str, 6, 6)),
llSubStringIndex(gCharIndex, llGetSubString(str, 7, 7)) );
vector GridPos5 = GetGridPos( llSubStringIndex(gCharIndex, llGetSubString(str, 8, 8)),
llSubStringIndex(gCharIndex, llGetSubString(str, 9, 9)) );

// First set the alpha to the lowest possible.
llSetAlpha(0.05, ALL_SIDES);

// Use these grid positions to display the correct textures/offsets.
ShowChars(GridPos1, GridPos2, GridPos3, GridPos4, GridPos5);

float Alpha;
for (Alpha = 0.10; Alpha <= 1.0; Alpha += 0.05)
llSetAlpha(Alpha, ALL_SIDES);
// See if we want to fade out as well.
if (gCellHoldDelay < 0.0)
// No, bail out. (Just keep showing the string at full strength).
return;
// Hold the text for a while.
llSleep(gCellHoldDelay);
// Now fade out.
for (Alpha = 0.95; Alpha >= 0.05; Alpha -= 0.05)
llSetAlpha(Alpha, ALL_SIDES);
// Make the text transparent to fully hide it.
llSetTexture(TRANSPARENT, ALL_SIDES);
}

RenderExtended(string str) {
// Look for escape sequences.
list Parsed = llParseString2List(str, [], [ESCAPE_SEQUENCE]);
integer ParsedLen = llGetListLength(Parsed);

// Create a list of index values to work with.
list Indices;
// We start with room for 6 indices.
integer IndicesLeft = 10;

integer i;
string Token;
integer Clipped;
integer LastWasEscapeSequence = FALSE;
// Work from left to right.
for (i = 0; i < ParsedLen && IndicesLeft > 0; i++) {
Token = llList2String(Parsed, i);

// If this is an escape sequence, just set the flag and move on.
if (Token == ESCAPE_SEQUENCE) {
LastWasEscapeSequence = TRUE;
}
else { // Token != ESCAPE_SEQUENCE
// Otherwise this is a normal token. Check its length.
Clipped = FALSE;
integer TokenLength = llStringLength(Token);
// Clip if necessary.
if (TokenLength > IndicesLeft) {
Token = llGetSubString(Token, 0, IndicesLeft - 1);
TokenLength = llStringLength(Token);
IndicesLeft = 0;
Clipped = TRUE;
}
else
IndicesLeft -= TokenLength;

// Was the previous token an escape sequence?
if (LastWasEscapeSequence) {
// Yes, the first character is an escape character, the rest are normal.

// This is the extended character.
Indices += [llSubStringIndex(EXTENDED_INDEX, llGetSubString(Token, 0, 0)) + 95];

// These are the normal characters.
integer j;
for (j = 1; j < TokenLength; j++)
Indices += [llSubStringIndex(gCharIndex, llGetSubString(Token, j, j))];
}
else { // Normal string.
// Just add the characters normally.
integer j;
for (j = 0; j < TokenLength; j++)
Indices += [llSubStringIndex(gCharIndex, llGetSubString(Token, j, j))];
}

// Unset this flag, since this was not an escape sequence.
LastWasEscapeSequence = FALSE;
}
}

// Use the indices to create grid positions.
vector GridPos1 = GetGridPos( llList2Integer(Indices, 0), llList2Integer(Indices, 1) );
vector GridPos2 = GetGridPos( llList2Integer(Indices, 2), llList2Integer(Indices, 3) );
vector GridPos3 = GetGridPos( llList2Integer(Indices, 4), llList2Integer(Indices, 5) );
vector GridPos4 = GetGridPos( llList2Integer(Indices, 6), llList2Integer(Indices, 7) );
vector GridPos5 = GetGridPos( llList2Integer(Indices, 8), llList2Integer(Indices, 9) );

// Use these grid positions to display the correct textures/offsets.
ShowChars(GridPos1, GridPos2, GridPos3, GridPos4, GridPos5);
}

integer ConvertIndex(integer index) {
// This converts from an ASCII based index to our indexing scheme.
if (index >= 32) // ' ' or higher
index -= 32;
else { // index < 32
// Quick bounds check.
if (index > 15)
index = 15;

index += 94; // extended characters
}

return index;
}

default {
state_entry() {
// Initialize the character index.
ResetCharIndex();
ME=(integer)llGetObjectName();
//llOwnerSay("Channel:"+(string)ME);
//llSay(0, "Free Memory: " + (string) llGetFreeMemory());
}

link_message(integer sender, integer channel, string data, key id) {
if (channel == (ME+DISPLAY_STRING)) {
RenderString(data);
return;
}
if (channel == (ME+DISPLAY_EXTENDED)) {
RenderExtended(data);
return;
}
if (channel == gCellChannel) {
// Extract the characters we are interested in, and use those to render.
string TextToRender = llGetSubString(data, gCellCharPosition, gCellCharPosition + 9);
if (gCellUseFading)
RenderWithEffects( TextToRender );
else // !gCellUseFading
RenderString( TextToRender );
return;
}
if (channel == (ME+REMAP_INDICES)) {
// Parse the message, splitting it up into index values.
list Parsed = llCSV2List(data);
integer i;
// Go through the list and swap each pair of indices.
for (i = 0; i < llGetListLength(Parsed); i += 2) {
integer Index1 = ConvertIndex( llList2Integer(Parsed, i) );
integer Index2 = ConvertIndex( llList2Integer(Parsed, i + 1) );

// Swap these index values.
string Value1 = llGetSubString(gCharIndex, Index1, Index1);
string Value2 = llGetSubString(gCharIndex, Index2, Index2);

gCharIndex = llDeleteSubString(gCharIndex, Index1, Index1);
gCharIndex = llInsertString(gCharIndex, Index1, Value2);

gCharIndex = llDeleteSubString(gCharIndex, Index2, Index2);
gCharIndex = llInsertString(gCharIndex, Index2, Value1);
}
return;
}
if (channel == (ME+RESET_INDICES)) {
// Restore the character index back to default settings.
ResetCharIndex();
return;
}
if (channel == (ME+SET_CELL_INFO)) {
// Change the channel we listen to for cell commands, and the
// starting character position to extract from.
list Parsed = llCSV2List(data);
gCellChannel = (integer) llList2String(Parsed, 0);
gCellCharPosition = (integer) llList2String(Parsed, 1);
gCellUseFading = (integer) llList2String(Parsed, 2);
gCellHoldDelay = (float) llList2String(Parsed, 3);
return;
}
if (channel == (ME+SET_THICKNESS)) {
// Set our z scale to thickness, while staying fixed
// in position relative the prim below us.
vector Scale = llGetScale();
float Thickness = (float) data;
// Reposition only if this isn't the root prim.
integer ThisLink = llGetLinkNumber();
if (ThisLink != 0 || ThisLink != 1) {
// This is not the root prim.
vector Up = llRot2Up(llGetLocalRot());
float DistanceToMove = Thickness / 2.0 - Scale.z / 2.0;
vector Pos = llGetLocalPos();
llSetPos(Pos + DistanceToMove * Up);
}
// Apply the new thickness.
Scale.z = Thickness;
llSetScale(Scale);
return;
}
if (channel == (ME+SET_COLOR)) {
vector newColor = (vector)data;
llSetColor(newColor, ALL_SIDES);
}
}
}

</lsl>

Presence Code Python

2010-03-09T09:07:28Z

New Spore:

Extremely incomplete example of how to log an avatar in and establish a presence. So far it only sends enough to temporarily show in-world. More to come....

N.B.: the packet ID number of a zero encoded pack is encoded and must be decoded before you can know what packet you are actually dealing with (Thanks John Hurliman/Eddy Stryker).

(based on a sample login script found at [http://www.libsecondlife.org/wiki/Login libsl login].)

<python>from struct import *
from zerocode import *
import md5
import xmlrpclib
import sys

import re
import httplib, urllib
from urlparse import urlparse
import socket, sys, time
import uuid
from makepacketdict import makepacketdict

from datetime import datetime

mypacketdictionary = {}
outputstring = ''
ack_need_list = []

logoutputflag = False

if logoutputflag:
temp = sys.stdout
sys.stdout =open('alog.txt','w')

def login(first, last, passwd, mac):
passwd_md5 = '$1$' + md5.new(passwd).hexdigest()

uri = 'http://127.0.0.1'
uri = 'https://login.agni.lindenlab.com/cgi-bin/login.cgi'
s = xmlrpclib.ServerProxy(uri)

login_details = {
'first': first,
'last': last,
'passwd': passwd_md5,
'start': 'last',
'major': '1',
'minor': '18',
'patch': '5',
'build': '3',
'platform': 'Win',
'mac': mac,
'options': [],
'user-agent': 'sl.py 0.1',
'id0': '',
'agree_to_tos': '',
'viewer_digest': '09d93740-8f37-c418-fbf2-2a78c7b0d1ea'
}
results = s.login_to_simulator(login_details)
print results

return results

def get_caps(results,cap_key, request_keys):

_, netloc, path, _, _, _ = urlparse(results[cap_key])

params = "<llsd><array><string>"+ request_keys[0]+"</string></array></llsd>"
headers = {"content-type": "application/xml"}
conn = httplib.HTTPSConnection(netloc)

conn.request("POST", path, params, headers)
response = conn.getresponse()

data = response.read()
conn.close()
return data

def ExtractCap(cap_result):
trim_xml = re.compile(r"<key>([a-zA-Z_]+)</key><string>([a-zA-Z_:/0-9-.]+)</string>")
new_key = trim_xml.search(cap_result).group(1)
new_cap = trim_xml.search(cap_result).group(2)
return new_key, new_cap

def scheduleacknowledgemessage(data):
if not ord(data[0])&0x40:
print "OOOPS! Got asked to ack a message that shouldn't be acked"

return
else:
ID = data[1:5]
if (ord(data[0])&0x40) & 0x80: ID = zero_decode_ID(ID) #impossible
ack_need_list.append(unpack(">L",ID)[0])
#ack_need_list.append(unpack(">L",data[1:5])[0])
#print "ack needed","insdie schedule ack_need_list", ack_need_list

return

def packacks():
acksequence = ""
for msgnum in ack_need_list:
acksequence += pack("<L", msgnum)

return acksequence

#def sendacks():
# if len(ack_need_list)>0:

#===============================================================================
# {
# UUIDNameRequest Low NotTrusted Unencoded
# {
# UUIDNameBlock Variable
# { ID LLUUID }
# }
# }
#===============================================================================

def sendUUIDNameRequest(sock, port, host, currentsequence,aUUID):

packed_data = ""
fix_ID = int("ffff0000",16)+ 235
data_header = pack('>BLB', 0x00,currentsequence,0x00)

for x in aUUID:
packed_data += uuid.UUID(x).bytes

packed_data += pack("L",fix_ID) + pack(">B",len(aUUID)) + packed_data

sock.sendto(packed_data, (host, port))
return

def sendRegionHandshakeReply(sock, port, host, currentsequence,agentUUID,sessionUUID):
packed_data = ""

low_ID = "ffff00%2x" % 149
data_header = pack('>BLB', 0x00,currentsequence,0x00)
packed_data += uuid.UUID(agentUUID).bytes+uuid.UUID(sessionUUID).bytes+ pack(">L",0x00)
packed_data = data_header + pack(">L",int(low_ID,16))+packed_data
sock.sendto(packed_data, (host, port))
#print "RegionHandshakeReply", ByteToHex(packed_data)
return

def sendAgentUpdate(sock, port, host, currentsequence, result):

#AgentUpdate

tempacks = packacks()
del ack_need_list[:]
if tempacks == "":
flags = 0x00
else:
flags = 0x10

#print "tempacks is:", ByteToHex(tempacks)

data_header = pack('>BLB', flags,currentsequence,0x00)
packed_data_message_ID = pack('>B',0x04)
packed_data_ID = uuid.UUID(result["agent_id"]).bytes + uuid.UUID(result["session_id"]).bytes
packed_data_QuatRots = pack('<ffff', 0.0,0.0,0.0,0.0)+pack('<ffff', 0.0,0.0,0.0,0.0)
packed_data_State = pack('<B', 0x00)
packed_data_Camera = pack('<fff', 0.0,0.0,0.0)+pack('<fff', 0.0,0.0,0.0)+pack('<fff', 0.0,0.0,0.0)+pack('<fff', 0.0,0.0,0.0)
packed_data_Flags = pack('<fLB', 0.0,0x00,0x00)

encoded_packed_data = zero_encode(packed_data_message_ID+packed_data_ID+packed_data_QuatRots+packed_data_State+packed_data_Camera+packed_data_Flags)

packed_data = data_header + encoded_packed_data+tempacks

# print "sending AgentUpdate to server",ByteToHex(packed_data_header+zero_decode(encoded_packed_data)+ tempacks)

sock.sendto(packed_data, (host, port))
return

def sendCompletePingCheck(sock, port, host, currentsequence,data,lastPingSent):
# print "data from PingCHeck", ByteToHex(data)

data_header = pack('>BLB', 0x00,currentsequence,0x00)
packed_data_message_ID = pack('>B',0x02)
packed_data = data_header + packed_data_message_ID+pack('>B', lastPingSent)
print "CompletePingCheck packet sent:", ByteToHex(packed_data)
sock.sendto(packed_data, (host, port))

return

def sendPacketAck(sock, port, host,currentsequence):

tempacks = packacks()
templen = len(ack_need_list)
del ack_need_list[:]
data_header = pack('>BLB',0x00,currentsequence,0x00)
packed_data_message_ID = pack('>L',0xFFFFFFFB)
packed_ack_len = pack('>B',templen)

packed_data = data_header + packed_data_message_ID + packed_ack_len + tempacks
#===============================================================================
# t = datetime.now()
# t.strftime("%H:%M:%S")
# ti = "%02d:%02d:%02d.%06d" % (t.hour,t.minute,t.second,t.microsecond)
# print ti, "PacketAck packet sent:", ByteToHex(packed_data)
#===============================================================================
sock.sendto(packed_data, (host, port))
return

def sendLogoutRequest(sock, port, host,seqnum,aUUID,sUUID):
packed_data = ""
packed_data_message_ID = pack('>L',0xffff00fc)
data_header = pack('>BLB', 0x00,seqnum,0x00)
packed_data += uuid.UUID(aUUID).bytes+uuid.UUID(sUUID).bytes+ pack(">L",0x00)

packed_data = data_header + packed_data_message_ID + packed_data
sock.sendto(packed_data, (host, port))
return

def establishpresence(host, port, circuit_code):

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
#Sending packet UseCircuitCode <-- Inits the connection to the sim.
data = pack('>BLBL',0x00,0x01,00,0xffff0003) + pack('<L',circuit_code) + uuid.UUID(result["session_id"]).bytes+uuid.UUID(result["agent_id"]).bytes
sock.sendto(data, (host, port))

#ISending packet CompleteAgentMovement <-- establishes the agent's presence
data = pack('>BLBL',0x00,0x02,00,0xffff00f9) + uuid.UUID(result["agent_id"]).bytes + uuid.UUID(result["session_id"]).bytes + pack('<L', circuit_code)
sock.sendto(data, (host, port))

sendAgentUpdate(sock, port, host, 3, result)
aUUID = [result["agent_id"]]
sendUUIDNameRequest(sock, port, host, 4,aUUID)
#

buf = 100
i = 0
trusted_count = 0
ackable = 0
trusted_and_ackable = 0
ack_need_list_changed = False
seqnum = 5
lastPingSent = 0
trusted = 0
while True:
if ack_need_list_changed:
ack_need_list_changed = False
seqnum += 1
sendPacketAck(sock, port, host,seqnum)
#sendAgentUpdate(sock, port, host, seqnum, result)
seqnum += 1
#sendacks()
i += 1
data,addr = sock.recvfrom(buf)
t = datetime.now()
t.strftime("%H:%M:%S")

if not data:
print "Client has exited!"

break
else:
test = ByteToHex(data).split()
#print test
ID = data[6:12]
#print "ID =", ByteToHex(ID)
if ord(data[0])&0x80:
ID = zero_decode_ID(data[6:12])

if ord(data[0])&0x40:
scheduleacknowledgemessage(data);
ack_need_list_changed = True
#print "ID =", ByteToHex(ID)
#print "ID =", unpack(">L", ID[:4])
if ID[0] == '\xFF':
if ID[1] == '\xFF':
if ID[2] == '\xFF':
myentry = mypacketdictionary[("Fixed" , "0x"+ByteToHex(ID[0:4]).replace(' ', ''))]
if myentry[1] == "Trusted":
trusted += 1;
ti = "%02d:%02d:%02d.%06d" % (t.hour,t.minute,t.second,t.microsecond)
print ti, "Message #", i, "trusted count is", trusted,"Flags: 0x" + test[0], myentry, "sequence #", unpack(">L",data[1:5])

#if myentry[1] == "Trusted": trusted_count += 1;print "number of trusted messages =", trusted_count
#if ord(data[0])&0x40 and myentry[1] == "Trusted": trusted_and_ackable += 1; print "trusted_and_ackable =", trusted_and_ackable
#if ord(data[0])&0x40: ackable += 1; print "number of ackable messages = ", ackable
else:
myentry = mypacketdictionary[("Low",int(ByteToHex(ID[2:4]).replace(' ', ''),16))]
if myentry[1] == "Trusted":
trusted += 1;
ti = "%02d:%02d:%02d.%06d" % (t.hour,t.minute,t.second,t.microsecond)
print ti, "Message #", i,"trusted count is", trusted,"Flags: 0x" + test[0], myentry, "sequence #", unpack(">L",data[1:5])
if myentry[0] == "UUIDNameReply":
pass
#print ByteToHex(data)
#print data[:28]
#print data[28:36],data[38:45]
elif myentry[0] == "RegionHandshake":
sendRegionHandshakeReply(sock, port, host, seqnum,result["agent_id"],result["session_id"])
seqnum += 1

#if myentry[1] == "Trusted": trusted_count += 1;print "number of trusted messages =", trusted_count
#if ord(data[0])&0x40 and myentry[1] == "Trusted": trusted_and_ackable += 1; print "trusted_and_ackable =", trusted_and_ackable
#if ord(data[0])&0x40: ackable += 1; print "number of ackable messages = ", ackable
else:
myentry = mypacketdictionary[("Medium", int(ByteToHex(ID[1:2]).replace(' ', ''),16))]
if myentry[1] == "Trusted":
trusted += 1;
ti = "%02d:%02d:%02d.%06d" % (t.hour,t.minute,t.second,t.microsecond)
print ti, "Message #", i,"trusted count is", trusted,"Flags: 0x" + test[0], myentry, "sequence #", unpack(">L",data[1:5])

#if myentry[1] == "Trusted": trusted_count += 1;print "number of trusted messages =", trusted_count
#if ord(data[0])&0x40 and myentry[1] == "Trusted": trusted_and_ackable += 1; print "trusted_and_ackable =", trusted_and_ackable
#if ord(data[0])&0x40: ackable += 1; print "number of ackable messages = ", ackable
else:
myentry = mypacketdictionary[("High", int(ByteToHex(ID[0]), 16))]
if myentry[0] == "StartPingCheck":
print "data from StartPingCheck", test
sendCompletePingCheck(sock, port, host, seqnum,data,lastPingSent)
lastPingSent += 1
seqnum += 1

if myentry[1] == "Trusted":
trusted += 1;
ti = "%02d:%02d:%02d.%06d" % (t.hour,t.minute,t.second,t.microsecond)

print ti, "Message #", i,"trusted count is", trusted,"Flags: 0x" + test[0], myentry, "sequence #", unpack(">L",data[1:5])

#if myentry[1] == "Trusted": trusted_count += 1;print "number of trusted messages =", trusted_count
#if ord(data[0])&0x40 and myentry[1] == "Trusted": trusted_and_ackable += 1; print "trusted_and_ackable =", trusted_and_ackable
#if ord(data[0])&0x40: ackable += 1; print "number of ackable messages = ", ackable

sendLogoutRequest(sock, port, host,seqnum,myAgentID,mySessionID)

sock.close()
print "final number of trusted messages =", trusted_count

return

result = login("first", "last", "password", MAC)

mypacketdictionary = makepacketdict()

myhost = result["sim_ip"]
myport = result["sim_port"]
mycircuit_code = result["circuit_code"]

establishpresence(myhost, myport, mycircuit_code)

#cap_out = get_caps(result,"seed_capability", ["ChatSessionRequest"])

</python>
[[Category: AW Groupies]]

User:Jor3l Boa/PHP/n2k.php

2010-03-07T09:17:14Z

New Spore:

PHP Based name2Key service.

n2k.php:
<php>
// PHP name2Key by Jor3l Boa
// -------------------------
// Released under Creative Commons 3.0
// - support+n2k@sltools.biz
// -------------------------

function getPage($web) {
$html = "";
$ch = curl_init($web);
curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.12) Gecko/20070508 Firefox/1.5.0.12");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
curl_setopt($ch, CURLOPT_AUTOREFERER, 1);
curl_setopt($ch, CURLOPT_TIMEOUT, 5);
$html = curl_exec($ch);
if(curl_errno($ch)) {
$html = "";
}
curl_close ($ch);
return $html;
}
function getBetween($content,$start,$end){
//by Jor3l :)
$a1 = strrpos($content,$start);
$content = substr($content,$a1 + strlen($start));
while($a2 = strrpos($content,$end)) {
$content = substr($content,0,$a2);
}
return $content;
}

function name2Key($name) {
$SL_SEARCH = 'http://search.secondlife.com/client_search.php?session=00000000-0000-0000-0000-000000000000&q=';
$sName = split(' ',$name);
$data = getPage($SL_SEARCH.$sName[0].'%2520'.$sName[1]);
$uuid = getBetween($data,'secondlife:///app/agent/','/about');
return $uuid;
}

</php>

example:
<php>
<?
require_once('n2k.php');
$uuid = name2key('FirstName LastName');
echo $uuid;
?>
</php>

<b>NOTE ON HOSTING PROVIDERS:</b>
Some hosting providers, notably GoDaddy, do not allow outbound traffic from their servers. If you find that this script returns nothing, no matter what you try, that may be your issue. The only fix is to switch providers to one that does allow outbound traffic.<br/><br/>
<I>For an LSL version, see also: [[Name2Key_in_LSL]]</i>

LSL HTTP server/examples/kellys stupid web status updater

2010-03-05T19:10:31Z

New Spore:

== What ==
This is a dead stupid, insecure and simple system that will update the floating text above a prim according to what is entered in the web form. Uses html forms, python and LSL. This is about as simple as it gets, I think.

== index.html ==
A simple webform that sends the input to our cgi.
<html4strict><html>
<body>
<div align="center">
<br><br><br>
<form ACTION="cgi-bin/post.cgi" METHOD="GET">
<textarea name="Message" rows="5" cols="40" onfocus="this.value=''; this.onfocus=null;">Enter your status update here.</textarea>
<P>
<INPUT TYPE="submit" title="FOO">
</form>
</div>
<body>
</html></html4strict>
== post.cgi ==
A simple CGI that takes GETs and looks for two parameters:
* URL: if found will write the value to a file
* Message: if found will read from the file and send the contents to the url in the file
Bugs:
* Entering no text in the form will cause the cgi to error.
Errata:
* This is probably really insecure.
* You need to create the file 'my_url' (or whatever you set file_name as) in your cgi-bin directory.
* That file needs to be readable and writable by your cgi. Depending on your setup something like this might work:
: touch my_url
: chmod 600 my_url
* You may need to be more permissive depending on your server configuration, but this worked on my shared hosting system.

<python>
#!/usr/bin/python

import cgi, urllib2, urllib
import cgitb
cgitb.enable()

# This file needs to be readable and writable from this cgi
file_name = "my_url"

form = cgi.FieldStorage()

# If we have Message then this is a status update.
if "Message" in form:
# Redirect back to the form
print "Status: 302 Moved"
print "Location: http://www.myurl.com/path/to/form"
print

# Read in the url from the file
f = open(file_name,'r')
base_url = f.read()

# Build the complete url with query args.
message = form["Message"].value
args = "?Message=%s" % urllib.quote(message)

# Make the request, giving the status to the script.
response = urllib2.urlopen(base_url + args)

# If we have URL then this is an URL update
if "URL" in form:
# Write the url to the file, overwriting the existing file.
f = open(file_name,'w')
f.write(form["URL"].value)

# Let the caller know it worked.
print "Content-Type: text/html"
print
print "OK"
</python>

== status.lsl ==
<lsl>
// Set this to whatever text you want above your status
string header = "My Status:\n";
// This is the url to the post.cgi from above
string updater_url = "http://mywebsite.com/cgi-bin/post.cgi";

// The magic changed flags to know when to re-request an url
// CHANGED_REGION | CHANGED_REGION_START | CHANGED_TELEPORT
integer CHANGED_URL = 1792;

// Setup run anytime we think our url has been lost.
setup()
{
llSetObjectName("HTTP Server: Status Updates");
llRequestURL();
}

// Debug incoming requests to see all header information.
debug(key id, string method, string body)
{
llOwnerSay(method + ": " + body);
list headers = ["x-script-url","x-path-info","x-query-string","x-remote-ip","user-agent"];
integer i;
for (i=0;i<5;++i)
{
llOwnerSay(llList2String(headers,i) + ": " + llGetHTTPHeader(id,llList2String(headers,i)));
}
}

default
{
// These events mean we have lost any urls we had and need to run setup()
state_entry() { setup(); }
on_rez(integer n) { setup(); }
changed(integer c) { if (c & (CHANGED_URL) ) setup(); }

http_request(key id, string method, string body)
{
// debug(id, method, body);

if (method == URL_REQUEST_GRANTED)
{
// Register our url for new status updates.
llHTTPRequest(updater_url + "?URL=" + body + "/",[],"");
}
else if (method == URL_REQUEST_DENIED)
{
// Might be good to have this email.
llSay(0, "Something went wrong, no url. " + body);
}
else if (method == "GET")
{
// Process a status update by parsing the query string
string t = llGetHTTPHeader(id,"x-query-string");
list l = llParseString2List(t,["?","=","&"],[]);

// We want the value after Message
integer i = llListFindList(l,["Message"]) + 1;

// If there was no Message argument then i = (-1) + 1 => 0.
// As long as i > 0 we found Message so put up whatever came next as the status.
if (i > 0)
{
llSetText(header + llUnescapeURL(llList2String(l,i)),<1,1,0>,1);
llHTTPResponse(id,200,"OK");
}
else
{
llHTTPResponse(id,400,"Must Specify a message!");
}
}
else
{
llHTTPResponse(id,405,"Method unsupported");
}
}
}
</lsl>

LSL HTTP server/examples/kurais stupid web status updater

2010-03-05T19:09:11Z

New Spore:

== What ==
*Based on [[LSL_http_server/examples/kellys_stupid_web_status_updater|Kellys stupid web status updater]].
*Isn't so stupid as Kellys, i hope. *lol*
: Kills me not, this is my first try with python xD
*Uses html forms, python and LSL.
*Fixed the cgi error bug with empty messages
*Add status reports for write to file error und success URL update

== index.html ==
A simple webform that sends the input to our cgi.
<html4strict><html>
<body>
<div align="center">
<br><br><br>
<form ACTION="cgi-bin/post.cgi" METHOD="GET">
<textarea name="Message" rows="5" cols="40" onfocus="this.value=''; this.onfocus=null;">Enter your status update here.</textarea>
<P>
<INPUT TYPE="submit" title="FOO">
</form>
</div>
<body>
</html></html4strict>
== post.cgi ==
* That file needs to be readable and writable by your cgi. Depending on your setup something like this might work:
: touch my_url
: chmod 600 my_url

<python>
#!/usr/bin/python

##############################################
# Original written by Kelly Linden #
# Modified by Kuraiko Yoshikawa (2009/07/28) #
##############################################

import cgi, urllib2, urllib
import cgitb
cgitb.enable()

# This file needs to be readable and writable from this cgi
file_name = "my_url"

form = cgi.FieldStorage()

# Set the URL of your form
url = "enter your form url"

# If we haven't a Message or URL let the user know it and redirect to the form
if "Message" not in form and "URL" not in form:

print "Content-Type: text/html"
print
print "<html><head><meta http-equiv=\"refresh\" content=\"5; URL=%s\"></head>" %url
print "<body style=\"text-align: center; margin-top: 20px;\">"
print "Please fill in the message field.<br><a href=\"%s\">Redirection to the form in 5 seconds</a>" %url
print "</body></html>"

# If we have URL param then this is an URL update
elif "URL" in form:
# Intercept errors
try:
# Write the url to the file, overwriting the existing file.
f = open(file_name,'w')
f.write(form["URL"].value)

# Let the caller know it worked.
print "Content-Type: text/html"
print
print "OK"
except:
# it has an error.
print "Content-Type: text/html"
print
print "ERROR|%s" %file_name

# We have Message then this is a status update.
else:
# Redirect back to the form
print "Status: 302 Moved"
print "Location: %s" %url
print

# Read in the url from the file
f = open(file_name,'r')
base_url = f.read()

# Build the complete url with query args.
message = form["Message"].value
args = "?Message=%s" % urllib.quote(message)

# Make the request, giving the status to the script.
response = urllib2.urlopen(base_url + args)
</python>

== status.lsl ==
<lsl>

////////////////////////////////////////////////
// Original written by Kelly Linden //
// Modified by Kuraiko Yoshikawa (2009/07/28) //
////////////////////////////////////////////////

// Set this to whatever text you want above your status
string header = "My Status:\n";
// This is the url to the post.cgi from above
string updater_url = "<url to your python script>";

// The magic changed flags to know when to re-request an url
// CHANGED_REGION | CHANGED_REGION_START | CHANGED_TELEPORT
integer CHANGED_URL = 1792;

key request;
// Setup run anytime we think our url has been lost.
setup()
{
llSetObjectName("HTTP Server: Status Updates");
llRequestURL();
}

// Debug incoming requests to see all header information.
debug(key id, string method, string body)
{
llOwnerSay(method + ": " + body);
list headers = ["x-script-url","x-path-info","x-query-string","x-remote-ip","user-agent"];
integer i;
for (i=0;i<5;++i)
{
llOwnerSay(llList2String(headers,i) + ": " + llGetHTTPHeader(id,llList2String(headers,i)));
}
}

default
{
// These events mean we have lost any urls we had and need to run setup()
state_entry()
{
setup();
}
on_rez(integer n)
{
setup();
}
changed(integer c)
{
if (c & (CHANGED_URL) ) setup();
}

http_request(key id, string method, string body)
{
//debug(id, method, body);

if (method == URL_REQUEST_GRANTED)
{
// Register our url for new status updates.
request = llHTTPRequest(updater_url + "?URL=" + body + "/",[],"");
}
else if (method == URL_REQUEST_DENIED)
{
// Might be good to have this email.
llSay(0,"Something went wrong, no url. " + body);
}
else if (method == "GET")
{
// Process a status update by parsing the query string
string t = llGetHTTPHeader(id,"x-query-string");
list l = llParseString2List(t,["?","=","&"],[]);

// We want the value after Message
integer i = llListFindList(l,["Message"]) + 1;

// If there was no Message argument then i = (-1) + 1 => 0.
// As long as i > 0 we found Message so put up whatever came next as the status.
if (i > 0)
{
llSetText(header + llUnescapeURL(llList2String(l,i)),<1,1,0>,1);
llHTTPResponse(id,200,"OK");
}
else
{
llHTTPResponse(id,400,"Must Specify a message!");
}
}
else
{
llHTTPResponse(id,405,"Method unsupported");
}
}

http_response(key request_id, integer status, list meta, string body)
{
if(request_id == request)
{
list t = llParseString2List(body, ["|"], [""]);
string t0 = llStringTrim(llList2String(t, 0), STRING_TRIM);
string t1 = llStringTrim(llList2String(t, 1), STRING_TRIM);
if(t0 == "OK")
{
llSay(0, "URL successfully updated.");
}
else if (t0 == "ERROR")
{
llSay(0, "Can't write the URL to the file '" + t1 +
"'. Please check if the file exists and the script has write permissions.");
}
else
{
llSay(0, "Something went wrong.\n" + body);
}
}
}
}

</lsl>

User:Takat Su/Name2Key

2010-03-05T19:07:00Z

New Spore:

{{LSL Header}}__NOTOC__

== Name2Key ==
'''This is an update to Maeva Anatine's excellent suggestion for an updated name2key function. Rather than overwrite all her work, I created this page. The idea is DEFINITELY hers - I just am creating an alternate implementation.
'''

Still missing Name2Key functions in your code? Still relying on external databases that are not always up to date with latests SL subscribers?

Well now you can solve this by yourself, within your LSL script! All you have to do is to rely on LL Search engine!

I put a kind of "library" and a sample of usage for your convenience

To use, you make an llHttpRequest to the application running on the Google Application Server (a free service for moderate users). The URL looks like this: http://name2key.appspot.com/?name=firstname%20lastname i.e. the first name of the person you want to look up is separated from their last name by "%20" (this is how the space character is coded in URLs). The application doesn't care if you get the case correct. The application will format the body of the return as follows: firstname lastname:key, where firstname and lastname will be capitalized correctly and the key is either the key for the person or the null key (00000000-0000-0000-0000-000000000000). It really isn't much code if you prefer to code it into your main script rather than rely on an external script for the lookup.

<div id="box">

== Library ==

<lsl>
integer cmdName2Key = 19790;
integer cmdName2KeyResponse = 19791;

list gRequests;

key requestName2Key( string inName ) {
list lNameParts = llParseString2List( inName, [" "], [] );
string lFirstName = llList2String( lNameParts, 0 );
string lLastName = llList2String( lNameParts, 1 );
return llHTTPRequest( "http://name2key.appspot.com/?name=" + lFirstName + "%20" + lLastName, [], "" );
}

default {
link_message( integer inFromPrim, integer inCommand, string inName, key inKey ) {
if( inCommand == cmdName2Key )
gRequests += [requestName2Key( inName ), inKey ];
}

http_response(key inKey, integer inStatus, list inMetaData, string inBody ) {
integer lPosition = llListFindList( gRequests, [inKey]);
if( lPosition != -1 ) {
llMessageLinked( LINK_SET, cmdName2KeyResponse, inBody, llList2Key( gRequests, lPosition+1 ) );
gRequests = llDeleteSubList( gRequests, lPosition, lPosition + 1 );
}
}
}
</lsl>
</div>

<div id="box">
== Usage sample ==
<lsl>
integer cmdName2Key = 19790;
integer cmdName2KeyResponse = 19791;

default {
state_entry() {
llMessageLinked( LINK_SET, cmdName2Key, "Test Name", NULL_KEY );
}

link_message( integer inFromPrim, integer inCommand, string inKeyData, key inReturnedKey ) {
if( inCommand == cmdName2KeyResponse ) {
list lParts = llParseString2List( inKeyData, [":"], [] );
string lName = llList2String( lParts, 0 );
key lKey = (key)llList2String(lParts, 1 );
}
}
}</lsl></div>

<div id="box">
== Google App Python Code ==
<lsl>
from google.appengine.ext import webapp
from google.appengine.ext.webapp.util import run_wsgi_app
import urllib, urlparse

kURL = 'http://vwrsearch.secondlife.com/client_search.php?session=00000000-0000-0000-0000-000000000000&q='
kProfile = "Resident profile"
kResult = "secondlife:///app/agent/"

class MainPage( webapp.RequestHandler ):
def get(self):
inName = self.request.get("name").upper()
name = inName.replace(" ", "%20")
data = urllib.urlopen(kURL + name).read()
start = data.index( kProfile )
foundName = data[start+18:start+18+len(inName)]
key = '00000000-0000-0000-0000-000000000000'
if foundName.upper() == inName:
start = data.index( kResult )
key = data[start+len(kResult):start+len(kResult)+36]
else:
foundName = inName

self.response.out.write("%s:%s" % (foundName, key))

application = webapp.WSGIApplication(
[('/', MainPage)],
debug = True)

def main():
run_wsgi_app(application)

if __name__ == "__main__":
main()
</lsl></div>

<div id="box">
== app.yaml file ==
<lsl>
application: name2key
version: 1
runtime: python
api_version: 1

handlers:
- url: .*
script: name2key.py
</lsl></div>

<div id="box">
== Comments ==
<div style="padding: 0.5em;">
The main difference is that I wrote a an app for the google app engine that act as a relay. Since I was going that far, it also parses the return, strips out all the extraneous stuff and just returns you the name and key separated by a colon.
</div></div>
[[User:Takat Su|Takat Su]]

{{LSLC|Library}}{{LSLC|Examples|Name2Key}}

Linden Lab Official:Reg API Examples

2010-03-05T19:05:06Z

New Spore: /* Python */

{{:Web Services Portal/navigation}}

The following examples illustrate using the Reg API to register a new user with a specified Second Life first name and last name. The example code first checks to determine the availability of the selected first and last name, and either registers the user or returns an error message if the name is already taken.
__TOC__
<br clear="all"/>

== LLSD library downloads ==

To use a library:
# Remove the -lib suffix from the file name.
# Put the file in the same directory as the application code, such as the examples below.

* [https://secure-web10.secondlife.com/developers/third_party_reg/llsd_libs/llsd.rb-lib Ruby LLSD library] (version 1.3)
* [https://secure-web10.secondlife.com/developers/third_party_reg/llsd_libs/llsd.php-lib PHP LLSD library] (version 1.0)
* [https://secure-web10.secondlife.com/developers/third_party_reg/llsd_libs/llsd.py-lib Python LLSD library] (version 1.2)
* [https://secure-web10.secondlife.com/developers/third_party_reg/llsd_libs/llsd.pm-lib Perl LLSD library] (version 1.0)

NOTE: The PHP scripts only work with PHP4.

An externally developed Java implementation of LLSD and RegAPI is available at http://mimuve.cs.st-andrews.ac.uk/llsd-java/src/llsd-java-0.2.1.zip . Code written by Xugu Madison, copyright held by University of St Andrews, and made available under the BSD license. Tested with Java 1.5.

Question: what version of each language is required?

== Example code ==

=== Ruby ===

This ruby example shows how to use the Registration API.

<ruby>require 'llsd'

# 0 - get capability urls
# 1 - get error codes
# 2 - get the available last names
# 3 - check to see of a username + last name combo is taken
# 4 - register the user with this username + last name combo

get_capabilities_url = "https://cap.secondlife.com/get_reg_capabilities"

# grab command line args
if ARGV.length == 3
first_name = ARGV[0]
last_name = ARGV[1]
password = ARGV[2]
else
puts "Please pass in your second life first name, last name, and password as arguments."
puts "For example: ruby registration_api.rb joe linden 1234"

exit
end

# 0 - Get Capability URLS ##############################################
puts "========== Getting capabilities ===========\n"

post_body = "first_name=#{first_name}&last_name=#{last_name}&password=#{password}"
# create a url-encoded string to POST
response_xml = LLSD.post_urlencoded_data get_capabilities_url, post_body
# POST the capability url to get capabilities

puts "xml response:" # Print out response xml
puts response_xml

puts "\n"

capability_urls = LLSD.parse(response_xml) # Parse the xml

capability_urls.each { |k,v| puts "#{k} => #{v}"} # print out capabilities

# 1 - Print out error codes ##############################################
puts "\n\n========== Get Error Codes Example ===========\n"

if capability_urls['get_error_codes']
response_xml = LLSD.http_raw capability_urls['get_error_codes']
# GET the capability url for getting error codes

puts "xml response:" # Print out response xml
puts response_xml

error_codes = LLSD.parse(response_xml) # Parse the xml

error_codes.each {|error| puts "#{error[0]} => #{error[1]}"}
# print out all error codes
else
puts "Get_error_codes capability not granted to #{first_name} #{last_name}. Exiting Prematurely ..."
end

# 2 - Get Last Names Example ##############################################
puts "\n\n========== Get Last Names Example ===========\n"
if capability_urls['get_last_names']
response_xml = LLSD.http_raw capability_urls['get_last_names']
# GET the capability url for getting last names and ids

puts "xml response:" # Print out response xml
puts response_xml

last_names = LLSD.parse(response_xml) # Parse the xml

last_names.each {|k,v| puts "#{k} => #{v}"} # print out last names

# 3 - Check Name Example ##############################################
print "\n\n========== Check Name Example ===========\n"
if capability_urls['check_name']
random_username = 'tester' + Kernel.rand(10000).to_s # Generate a random username
valid_last_name_id = last_names.keys.first # Get the first valid last name id
params_hash = {"username" => random_username, "last_name_id" => valid_last_name_id }
# put it in a hash

xml_to_post = LLSD.to_xml(params_hash) # convert it to llsd xml

response_xml = LLSD.post_xml(capability_urls['check_name'], xml_to_post)

puts "posted xml:" # Print out response xml
puts xml_to_post

puts "xml response:" # Print out response xml
puts response_xml

is_name_available = LLSD.parse(response_xml) # Parse the xml

puts "Result (is name available?): #{is_name_available}" # Print the result

# 4 - Create User Example ##############################################
puts "\n\n========== Create User Example ===========\n"
if is_name_available and capability_urls['create_user']:
# fill in the rest of the hash we started in example 2 with valid data
params_hash["email"] = random_username + "@ben.com"
params_hash["password"] = "123123abc"
params_hash["dob"] = "1980-01-01"

xml_to_post = LLSD.to_xml(params_hash) # convert it to llsd xml

response_xml = LLSD.post_xml(capability_urls['create_user'], xml_to_post)

puts "posted xml:" # Print out response xml
puts xml_to_post

puts "xml response:" # Print out response xml
puts response_xml

result_hash = LLSD.parse(response_xml) # Parse the xml

puts "New agent id: #{result_hash['agent_id']}" # Print the result

# ALL DONE!!
else
puts "Create_user capability not granted to #{first_name} #{last_name}. Exiting Prematurely ..."
end
else
puts "Check_name capability not granted to #{first_name} #{last_name}. Exiting Prematurely ..."
end
else
puts "Get_last_names capability not granted to #{first_name} #{last_name}. Exiting Prematurely..."
end</ruby>

=== Python ===

<python>import llsd
import urllib2, random, sys

# This python example shows how to use the Registration API. The example goes as follows:

# 0 - get capability urls
# 1 - get error codes
# 2 - get the available last names
# 3 - check to see of a username + last name combo is taken
# 4 - register the user with this username + last name combo

get_capabilities_url = "https://cap.secondlife.com/get_reg_capabilities"

# grab command line args
if len(sys.argv) == 4:
first_name = sys.argv[1]
last_name = sys.argv[2]
password = sys.argv[3]
else:
print "Please pass in your second life first name, last name, and password as arguments. For example:"
print "python registration_api.py registration mackay 1234"

sys.exit()

# 0 - Get Capability URLS #################################################################
print "========== Getting capabilities ==========="

post_body = "first_name=%s&last_name=%s&password=%s" % (first_name, last_name, password) # create a url-encoded string to POST
response_xml = urllib2.urlopen(get_capabilities_url, post_body).read() # POST the capability url to get capabilities

print "xml response:" # Print out response xml
print response_xml

capability_urls = llsd.parse(response_xml) # Parse the xml

for id, name in capability_urls.items(): # Print out capabilities
print "%s => %s" % (id, name)

# 1 - Print out error codes ###############################################################
if 'get_error_codes' in capability_urls:
print "\n\n========== Get Error Codes Example ===========\n"

response_xml = urllib2.urlopen(capability_urls['get_error_codes']).read() # GET the capability url for getting error codes

print "xml response:" # Print out response xml
print response_xml

error_codes = llsd.parse(response_xml) # Parse the xml

for error in error_codes: # Print out capabilities
print "%s => %s" % (error[0], error[1])
else:
print "Get_error_codes capability not granted to %s %s. Now Exiting Prematurely ..." % (first_name, last_name)

# 2 - Get Last Names Example ##############################################################
if 'get_last_names' in capability_urls:
print "\n\n========== Get Last Names Example ==========="

response_xml = urllib2.urlopen(capability_urls['get_last_names']).read() # GET the capability url for getting last names and ids

print "xml response:" # Print out response xml
print response_xml

last_names = llsd.parse(response_xml) # Parse the xml

for id, name in last_names.items(): # Print out last names
print "%s => %s" % (id, name)

# 3 - Check Name Example ##################################################################
if 'check_name' in capability_urls:
print "\n\n========== Check Name Example ==========="

random_username = 'benny' + str(random.randrange(100,10000)) # Generate a random username
valid_last_name_id = last_names.keys()[0] # Get the first valid last name id
params_hash = {"username": random_username, "last_name_id": valid_last_name_id } # put it in a hash

xml_to_post = llsd.toXML(params_hash) # convert it to llsd xml

response_xml = urllib2.urlopen(capability_urls['check_name'], xml_to_post).read()

print "posted xml " # Print out response xml
print xml_to_post

print "xml response:" # Print out response xml
print response_xml

is_name_available = llsd.parse(response_xml) # Parse the xml

print "Result (is name available?): %s" % (is_name_available) # Print the result

# 4 - Create User Example #################################################################
if is_name_available and 'create_user' in capability_urls:
print "\n\n========== Create User Example ==========="

# fill in the rest of the hash we started in example 2 with valid data
params_hash["email"] = random_username + "@ben.com"
params_hash["password"] = "123123abc"
params_hash["dob"] = "1980-01-01"

xml_to_post = llsd.toXML(params_hash) # convert it to llsd xml

response_xml = urllib2.urlopen(capability_urls['create_user'], xml_to_post).read()

print "posted xml " # Print out response xml
print xml_to_post

print "xml response:" # Print out response xml
print response_xml

result_hash = llsd.parse(response_xml) # Parse the xml

print "New agent id: %s" % (result_hash["agent_id"]) # Print the result

# ALL DONE!!
else:
print "create_user capability not granted to %s %s. Now Exiting Prematurely ..." % (first_name, last_name)

else:
print "check_name capability not granted to %s %s. Now Exiting Prematurely ..." % (first_name, last_name)

else:
print "get_last_names capability not granted to %s %s. Now Exiting Prematurely ..." % (first_name, last_name)</python>

=== PHP ===
NOTE: This uses PHP4. See also [[Registration_API#Guidelines_and_tips|Guidelines and tips]].

<php><?php
require_once('llsd.php');

// FILL THESE IN WITH YOUR OWN CAPABILITY URLS
define('URI_CREATE_USER', '?????????');
define('URI_GET_LAST_NAMES', '?????????');
define('URI_CHECK_NAME', '?????????');

if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
if (is_name_available($_POST['username'], $_POST['last_name_id']))
{
$user = array
(
'username' => $_POST['username'],
'last_name_id' => (int)$_POST['last_name_id'],
'email' => $_POST['email'],
'password' => $_POST['password'],
'dob' => $_POST['dob_year'].'-'.$_POST['dob_month'].'-'.$_POST['dob_day']
);

$result = llsd_post(URI_CREATE_USER, $user);
print $result['agent_id'];
}
else
{
print 'SL name not available.';
}
}
?>

<h3>Create Second Life Account</h3>

<form action="<?php print $_SERVER['PHP_SELF']; ?>" method="post">

<table border="0" cellpadding="3" cellspacing="0">
<tr>
<td>First name:</td>
<td><input type="text" name="username" size="25" maxlength="31" value="" /></td>
</tr>
<tr>
<td>Last name:</td>
<td>
<select name="last_name_id">
<?php
$last_names = llsd_get(URI_GET_LAST_NAMES);
foreach ($last_names as $last_name_id => $name)
{
print '<option value="'.$last_name_id.'">'.$name.'</option>';
}
?>
</select>
</td>
</tr>
<tr>
<td>Password:</td>
<td><input type="password" name="password" size="20" value="" /></td>
</tr>
<tr>
<td>Email:</td>
<td><input type="text" name="email" size="35" value="" /></td>
</tr>
<tr>
<td>Date of brith:</td>
<td>
<select name="dob_day">
<?php
$days = get_days();
foreach ($days as $key => $value) { print '<option value="'.$key.'" '.$selected.'>'.$value.'</option>'; }
?>
</select>

<select name="dob_month">
<?php
$months = get_months();
foreach ($months as $key => $value) { print '<option value="'.$key.'" '.$selected.'>'.$value.'</option>'; }
?>
</select>

<select name="dob_year">
<?php
$years = get_years();
foreach ($years as $key => $value) { print '<option value="'.$key.'" '.$selected.'>'.$value.'</option>'; }
?>
</select>
</td>
</tr>
<tr>
<td></td>
<td><input type="submit" value="Create SL Account" /></td>
</table>

</form>

<?php
function get_months()
{
$months = array();
for ($i = 1; $i <= 12; $i++)
{
$key = date('n', mktime(0, 0, 0, $i, 1, 2000));
$value = date('M.', mktime(0, 0, 0, $i, 1, 2000));
$months[sprintf("%02d", $key)] = $value;
}
return $months;
}

function get_years()
{
$today = getdate();
$max_year = $today['year'] - 90;
$min_year = $today['year'] - 13;

$years = array();
for ($i = $min_year; $i >= $max_year; $i--)
{
$years[$i] = $i;
}
return $years;
}

function get_days()
{
$days = array();
for ($i = 1; $i <= 31; $i++)
{
$days[sprintf("%02d", $i)] = sprintf("%02d", $i);
}
return $days;
}

function is_name_available($username, $last_name_id)
{
$params = array('username' => $username, 'last_name_id' => (int)$last_name_id);
if (llsd_post(URI_CHECK_NAME, $params) == 'true')
{
return true;
}
return false;
}
?></php>

[[Category:RegAPI|Sample Code]]
[[Category:Web Service APIs]]