Second Life Wiki - User contributions [en]

Template:Main Page/Creation

2025-04-26T21:51:17Z

Garfield Linden: Add link to PBR Materials page

Template:Main Page/Creation

2025-04-26T21:47:32Z

Garfield Linden: Point to the Video Tutorials wiki page instead of secondlife.com/video, as the latter is rather lacking in content.

Template:Main Page/Creation

2025-04-26T21:45:08Z

Garfield Linden: Sculpted Prims -> Mesh

Template:Main Page/Creation

2025-04-26T21:43:13Z

Garfield Linden: WindLight -> Environment

Linden Lab Official:Reg API Examples

2024-10-20T00:36:20Z

Garfield Linden: Add syntax highlighting for code examples

{{Supported API}}
{{:API Portal/navigation|reg}}

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.

<syntaxhighlight lang="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
</syntaxhighlight>

=== Python ===

<syntaxhighlight lang="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 ==========="

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 "Finalize this user at: %s" % (result_hash["complete_reg_url"])

# 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)
</syntaxhighlight>

=== PHP ===
NOTE: This uses PHP4. See also [[Registration_API#Guidelines_and_tips|Guidelines and tips]].

<syntaxhighlight lang="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'],
);

$result = llsd_post(URI_CREATE_USER, $user);
header( "Location: " . $result['complete_reg_url'] );
}
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></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;
}
?>
</syntaxhighlight>

[[Category:RegAPI|Sample Code]]
[[Category:Web Service APIs]]

LSO

2024-08-28T00:20:08Z

Garfield Linden: openmetaverse.co is gone, and so is its wiki article on LSO. An older version of this page linked to a similar page on libsecondlife.org's wiki, which archive.org thankfully indexed. Let's link to that!

{{LSL Header|ml=*}}{{RightToc}}

Second Life has two LSL compilers, one which compiles into LSO bytecode and is executed by the simulator in the LSO {{Abbr|VM|Virtual machine}}, the other which compiles to {{Wikipedia|Common Intermediate Language|CIL}} and is executed by the simulator in the [[Mono]] VM. This article is about the LSO bytecode.

LSO is mostly a stack-based language with a reference-counted heap and a very odd function calling convention in which the caller allocates storage for the callee's local variables. All the gory details can be found at https://web.archive.org/web/20080430044527/https://www.libsecondlife.org/wiki/LSO, including some opcodes that are implemented in the interpreter but never outputted by the compiler (such as the handy DUP family of instructions for Forth-style programming, and PUSHIP/POPIP for implementing custom function calls/function pointers, jumptable-based switch statements and the like).

It's actually a reasonably powerful instruction set in some ways, but the compiler doesn't make use of it very well.

With the release of the Mono VM, LSO has been maintained for backwards compatibility.

=Bytecodes=

{|
|style="text-align: center;"|'''Argument Types'''
|colspan="2" style="text-align: center;"|'''Variable type codes'''
|- vAlign="top"
|
{| {{Prettytable}}
|-{{Hl2}}
! Type
! title="Size in Bytes" | Size
!
|-
| dword
| 4
|
|-
| short
| 2
|
|-
| byte
| 1
|
|-
| type
| 1
| upper 4 bits are type.Left <br/> lower 4 bits are type.Right
|}
|
{| {{Prettytable}}
|-{{Hl2}}
! Value
! Type
! title="Size in Bytes" | Size
|-
| 0
| void
| ?
|-
| 1
| integer
| 4
|-
| 2
| float
| 4
|-
| 3
| string
| 4
|}
|
{| {{Prettytable}}
|-{{Hl2}}
! Value
! Type
! title="Size in Bytes" | Size
|-
| 4
| key
| 4
|-
| 5
| vector
| 12
|-
| 6
| rotation
| 16
|-
| 7
| list
| 4
|}
|}
==By Task==
=== Pop Value ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/pop-value}}
|}

=== Duplicate Value ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
{{LSO Bytecodes/duplicate}}
|}

=== Store to Local ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/store-local}}
|}

=== Store to Global ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/store-global}}
|}

=== Load to Local ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/load-local}}
|}

=== Load to Global ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/load-global}}
|}

=== Push Local ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/push-local}}
|}

=== Push Global ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/push-global}}
|}

=== Push into List ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/push-list}}
|}

=== Push Zero Values ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/push-zeros}}
|}

=== Operators ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/operators}}
|}

=== Jump ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
!class="unsortable"|arg1 size
{{LSO Bytecodes/jump}}
|}

=== Return ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/return}}
|}

=== Stack to Heap ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/stack-to-heap}}
|}

=== Call Functions ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/functions}}
|}

=== Special Registers ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
{{LSO Bytecodes/push-register}}
|-
{{LSO Bytecodes/pop-register}}
|}

=== Miscellaneous ===
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"|Description
!class="unsortable"|arg0 size
{{LSO Bytecodes/misc}}
|}

== All Bytecodes ==
{| class="sortable" {{Prettytable}}
|-{{Hl2}}
!Name
!Value
!class="unsortable"{{!}}Description
!class="unsortable"{{!}}arg0 size
!class="unsortable"{{!}}arg1 size
{{LSO Bytecodes/misc}}
|-
{{LSO Bytecodes/pop-value}}
|-
{{LSO Bytecodes/pop-register}}
|-
{{LSO Bytecodes/duplicate}}
|-
{{LSO Bytecodes/store-local}}
|-
{{LSO Bytecodes/store-global}}
|-
{{LSO Bytecodes/load-local}}
|-
{{LSO Bytecodes/load-global}}
|-
{{LSO Bytecodes/push-local}}
|-
{{LSO Bytecodes/push-global}}
|-
{{LSO Bytecodes/push-register}}
|-
{{LSO Bytecodes/push-list}}
|-
{{LSO Bytecodes/push-zeros}}
|-
{{LSO Bytecodes/operators}}
|-
{{LSO Bytecodes/jump}}
|-
{{LSO Bytecodes/return}}
|-
{{LSO Bytecodes/stack-to-heap}}
|-
{{LSO Bytecodes/functions}}
|}

[[Category:Assets]]

Template:Main Page/Featured Pages

2024-08-02T20:01:30Z

Garfield Linden: Remove featured link to the Authorized Linden Dollar Reseller pilot program, which has been closed as per https://community.secondlife.com/blogs/entry/1621-concluding-the-authorized-l-reseller-pilot-program/

<div id="box">

<h2>'''News & Featured Pages'''</h2>
<div style="padding: 0.5em">
* '''[[Linden_Lab_Official:User_Groups|User Groups]]:''' Meet the Lindens and discuss Second Life developments
* '''[[Good Building Practices]]'''
* '''[[Pathfinding in Second Life]]'''
* '''[[Mesh]]'''
* '''[[Second Life Marketplace Direct Delivery FAQ|Direct Delivery FAQ]]'''
</div>
</div>

LlWorldPosToHUD

2024-01-24T21:51:26Z

Garfield Linden: Removing extraneous semicolon

{{LSL_Function/permission|PERMISSION_TRACK_CAMERA}}{{LSL_Function
|func=llWorldPosToHUD
|sort=WorldPosToHUD
|func_id=547
|func_sleep=0.0
|func_energy=10.0
|return_type=vector
|p1_type=vector|p1_name=world_pos
|func_desc
|return_text=position in HUD frame that would place the center of the HUD object directly over '''world_pos''' as viewed by the current camera.
|spec
|caveats=Only works for HUD attachments. The vector's X component will be 1.0 when '''world_pos''' is in front of camera and -1.0 when it is behind. Returns zero vector when no permissions have been granted.
|examples=
<source lang="lsl2">// llWorldPosToHUD() example
//
// Put this script on a HUD attachment (which attachment point doesn't matter).
// Touch to toggle 'tracking' on/off.
// Put an object at world_pos as reference for where the HUD should move when 'tracking'.

vector not_tracking_color = <1.0, 1.0, 1.0>; // white
vector tracking_front_color = <0.5, 0.0, 0.5>; // magenta
vector tracking_behind_color = <0.0, 0.5, 0.5>; // cyan

vector world_pos = <32,32,24>; // change this position as necessary, put a ref object here
integer tracking = FALSE;

default
{
state_entry()
{
llOwnerSay("Touch HUD to toggle tracking");
llRequestPermissions(llGetOwner(), PERMISSION_TRACK_CAMERA);
llSetAlpha(0.5, ALL_SIDES); // make object semi transparent
llSetColor(not_tracking_color, ALL_SIDES);
}

touch_start(integer total_number)
{
llRequestPermissions(llGetOwner(), PERMISSION_TRACK_CAMERA);
tracking = !tracking;
if (tracking)
{
llSetTimerEvent(0.01);
llSetColor(tracking_front_color, ALL_SIDES);
}
else
{
llSetTimerEvent(0.0);
llSetPos(<0,0,0>);
llSetColor(not_tracking_color, ALL_SIDES);
}
}

attach(key id)
{
if (id != NULL_KEY)
{
llSetPos(<0,0,0>);
tracking = FALSE;
llSetTimerEvent(0.0);
}
}

timer()
{
integer attachment_point = llGetAttached();
if (attachment_point >= ATTACH_HUD_CENTER_2 && attachment_point <= ATTACH_HUD_BOTTOM_RIGHT)
{
vector hud_pos = llWorldPosToHUD(world_pos);
if (hud_pos.x > 0.0)
{
// world-pos is in front of camera
llSetColor(tracking_front_color, ALL_SIDES);
}
else
{
// world_pos is behind camera
llSetColor(tracking_behind_color, ALL_SIDES);
}
// update HUD position
llSetPos(hud_pos);
}
}
}
</source>
|helpers
|also_functions=
{{LSL DefineRow||{{LSLG|llGetCameraAspect}}|}}
{{LSL DefineRow||{{LSLG|llGetCameraFOV}}|}}
{{LSL DefineRow||{{LSLG|llGetCameraPos}}|}}
{{LSL DefineRow||{{LSLG|llGetCameraRot}}|}}
|notes
|cat1=Camera
|cat2=Attachment
|cat3
|cat4
}}

User:Garfield Linden

2023-12-10T00:01:12Z

Garfield Linden: Created page with "Hello? How did I get here? I'm not good at computers."

Hello? How did I get here? I'm not good at computers.

LlSHA1String

2023-12-09T23:59:46Z

Garfield Linden: Direct residents to LSL's built-in llSHA256String and away from script implementations.

{{LSL_Function
|inject-1={{LSL Function/warning|Security|The SHA-1 hashing algorithm is considered broken but the attacks are largely still theoretical and not very practical. Consider the more secure [[llSHA256String]]. {{Wikipedia|SHA-1#Comparison_of_SHA_functions|Comparison of SHA functions}}}}
|func_id=343|func_sleep=0.0|func_energy=10.0
|func=llSHA1String|return_type=string|p1_type=string|p1_name=src
|func_footnote
|func_desc
|return_text=of 40 hex characters that is the {{Wikipedia|SHA-1|SHA-1}} security hash of {{LSLP|src}}.
|spec=LSL strings are stored in the UTF-8 format.
|caveats=There's no way to input a zero-byte value into this function, nor any byte value from 128-255, therefore it's currently broken for many purposes (like HMAC-SHA1). The reason is because LSL strings cannot have a unicode null character (U+0000) in them, and LSL has no escape code for the null character (many programming languages use \0 but LSL does not have this feature). llEscapeURL("%00") yields an empty string. As well, inside this function, each character with a Unicode integer value over U+0127 / 007F are dealt with in UTF-8 fashion: in the hex values, 0xC2 is appended to the byte value (hence 0x0080-0x00FF become 0xC280-0xC2FF inside the llSHA1String() routine). A JIRA has been filed for this.
|constants
|examples=
<source lang="lsl2">
llSay(0, llSHA1String("Hello, Avatar!")); // returns 2E73318E547AF1B28CC0C96F95DDC9B1EE906B8D
</source>

====Linux Example====
<pre>
$ echo -n 'Hello, Avatar!' | openssl sha1
2E73318E547AF1B28CC0C96F95DDC9B1EE906B8D
</pre>
|helpers
|also_functions=
{{LSL DefineRow||[[llMD5String]]}}
{{LSL DefineRow||[[llSHA256String]]}}
|also_tests
|also_events
|also_articles=
{{LSL DefineRow||[[SHA-1]] (script implementation)}}
|notes
|deepnotes=
Prior to this, the only way to get the SHA-1 hash was to use the LSL SHA-1 port: [[SHA-1]]
|history=
*{{SVN|1291|rev=98903|trunk=*|anchor=file13|ver=1.21.5.97417|ser=1.24.9.98650}} Initial introduction.
*{{SVN|1298|rev=99021|branch=OpenAL|ver=1.21.5.97417|ser=1.24.9.98650|path=branches/openal/indra/lscript/lscript_library/lscript_library.cpp}}
Integration into OpenAL branch.
* Date of Release [[ Release_Notes/Second_Life_Beta_Server/1.25#Server_Release_Notes.2C_Second_Life_Beta_Server_1.25.0 | 2008-10-31 ]]
|cat1=Hash
|cat2=Encoding
|cat3
|cat4
}}{{LSLC{{#var:lang}}|Encryption|llSHA1String}}

SHA-1

2023-12-09T23:52:23Z

Garfield Linden: Direct residents to built-in SHA functions; tweak wording.

{{LSL Header}}
{{LSL Function/warning|inline=*|Security|There are dire security implications to changing the K constants (these are the hex values near the end of the lines marked with "//k" comments). https://malicioussha1.github.io/}}

{{LSL New}} LSL now includes its own (faster) [[llSHA1String]] function, which removes the need for the UTF8_SHA1 variant from this library. Also consider the more secure [[llSHA256String]].

Performs a SHA-1 hash on the text. This is similar to an [[MD5]] hash, but is ''slightly'' more secure. Two versions of the function are provided: one for UTF-8 strings (all strings in LSL are UTF-8) and another for Base64 strings (for which you need to specify the data length in bits).

There are also two [[SHA-2]] script implementations ([[SHA-2#SHA-256|SHA-256]] & [[SHA-2#SHA-224|SHA-224]]), though consider the faster [[llSHA256String]] provided by LSL itself.

View {{Wikipedia|SHA-1}} for more information.

<source lang="lsl2">//////////////////////////////////////////////////////////////////////////////////////
//
// UTF-8 SHA-1 160
// Version 1.3
// ESL Compiled: "Nov 26 2013", "00:11:59"
// Copyright (C) 2013 Strife Onizuka
// Based on Pseudo-code from http://en.wikipedia.org/wiki/SHA-1
// https://wiki.secondlife.com/wiki/SHA-1
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation;
// version 3 of the License.
//
// This library 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this library. If not, see <http://www.gnu.org/licenses/>
// or write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
// Boston, MA 02111-1307 USA
//
//////////////////////////////////////////////////////////////////////////////////////

//===================================================//
// Combined Library v1.0 //
// "Nov 26 2013", "00:11:59" //
// Copyright (C) 2004-2012, Strife Onizuka (cc-by) //
// http://creativecommons.org/licenses/by/3.0/ //
//===================================================//
//{

string hexc="0123456789ABCDEF";

//} Combined Library

string Base64_SHA1(string plain, integer bit_length) {
integer H1 = 0x67452301;
integer H2 = 0xefcdab89;
integer H3 = 0x98badcfe;
integer H4 = 0x10325476;
integer H5 = 0xc3d2e1f0;

integer b = ((bit_length + 40) >> 5) | 15;//this works because we want the value to be one less than the next appropriate multiple of 16.
string buf = "AAA";
integer i = -5;
do buf += buf; while((i = -~i));
integer S = (6 * llSubStringIndex((plain)+"=", "="));
integer T = 0x80000000;
if(bit_length) {
if(S < bit_length) {
plain = llDeleteSubString(plain, S, 0x7FFFFFF0);
i = ((bit_length + 23) / 24) * 24;
do
plain += buf;
while((S += 576) < i);
}
T = 23 - ((~-(bit_length)) % 24);
T = (llBase64ToInteger(llGetSubString((llGetSubString(plain = llGetSubString(plain, 0, (bit_length / 6) | 3), -4, (~-(S / 6)))) + "AAAAA", 0, 5)) & (0xFFFFFF00 << T)) | (0x00000080 << T);
}
//llOwnerSay(llList2CSV([b,j, llStringLength(buf), llIntegerToBase64(j << (6 - ((b % 3) << 1)))]));
plain = llInsertString( llDeleteSubString(plain, -4, -1) +
llGetSubString(llIntegerToBase64(T), 0, 5) + buf, (-~((b << 4) / 3)),
llGetSubString(llIntegerToBase64(bit_length << (6 - ((b % 3) << 1))), 0, 5));
//llOwnerSay(llList2CSV([llStringLength(plain), Base64ToHex(plain), T]));
list x;
i = 0;
do {
integer A = H1;
integer B = H2;
integer C = H3;
integer D = H4;
integer E = H5;
x = (list)(bit_length = 0);//the zero gets flushed off the stack by the later loops
do {
T = llBase64ToInteger(buf = llGetSubString(plain, T = ((i + bit_length) << 4) / 3, T+6)) << (S = ((i + bit_length) % 3) << 1);
if(S)
T = T | (llBase64ToInteger("A" + (llDeleteSubString(buf, 0, 1))) >> (6 - S));
// llOwnerSay("W["+(string)j+"]="+hex(T));
x += T;
T += ((A << 5) | ((A >> 27) & 0x1F)) + (D ^ (B & (C ^ D))) + E + 0x5a827999;//k
E = D;
D = C;
C = ((B << 30) | ((B >> 2) & 0x3FFFFFFF));
B = A;
A = T;
} while(16 > (bit_length = -~bit_length));
// llOwnerSay(llList2CSV(hexm(x)));
do {
S = llList2Integer(x, -3) ^ llList2Integer(x, -8) ^ llList2Integer(x, -14) ^ llList2Integer(x, -16);
x = llList2List(x + (T = ((S << 1) | !!(S & 0x80000000))), -16, -1);
// llOwnerSay("W["+(string)j+"]="+hex(T));
T += ((A << 5) | ((A >> 27) & 0x1F)) + (D ^ (B & (C ^ D))) + E + 0x5a827999;//k
E = D;
D = C;
C = ((B << 30) | ((B >> 2) & 0x3FFFFFFF));
B = A;
A = T;
} while(20 > (bit_length = -~bit_length));
do {
S = llList2Integer(x, -3) ^ llList2Integer(x, -8) ^ llList2Integer(x, -14) ^ llList2Integer(x, -16);
x = llList2List(x + (T = ((S << 1) | !!(S & 0x80000000))), -16, -1);
// llOwnerSay("W["+(string)j+"]="+hex(T));
T += ((A << 5) | ((A >> 27) & 0x1F)) + (B ^ C ^ D) + E + 0x6ed9eba1;//k
E = D;
D = C;
C = ((B << 30) | ((B >> 2) & 0x3FFFFFFF));
B = A;
A = T;
} while(40 > (bit_length = -~bit_length));
do {
S = llList2Integer(x, -3) ^ llList2Integer(x, -8) ^ llList2Integer(x, -14) ^ llList2Integer(x, -16);
x = llList2List(x + (T = ((S << 1) | !!(S & 0x80000000))), -16, -1);
// llOwnerSay("W["+(string)j+"]="+hex(T));
T += ((A << 5) | ((A >> 27) & 0x1F)) + ((B & C) | (B & D) | (C & D)) + E + 0x8f1bbcdc;//k
E = D;
D = C;
C = ((B << 30) | ((B >> 2) & 0x3FFFFFFF));
B = A;
A = T;
} while(60 > (bit_length = -~bit_length));
do {
S = llList2Integer(x, -3) ^ llList2Integer(x, -8) ^ llList2Integer(x, -14) ^ llList2Integer(x, -16);
x = llList2List(x + (T = ((S << 1) | !!(S & 0x80000000))), -16, -1);
// llOwnerSay("W["+(string)j+"]="+hex(T));
T += ((A << 5) | ((A >> 27) & 0x1F)) + (B ^ C ^ D) + E + 0xca62c1d6;//k
E = D;
D = C;
C = ((B << 30) | ((B >> 2) & 0x3FFFFFFF));
B = A;
A = T;
} while(80 > (bit_length = -~bit_length));
H1 += A;
H2 += B;
H3 += C;
H4 += D;
H5 += E;
} while(b > (i += 16));
x = [H1, H2, H3, H4, H5];
i = -5;
buf = "";
do {
T = llList2Integer(x,i);
bit_length = 32;
do {
buf += llGetSubString(hexc, b = ((T >> (bit_length -= 4)) & 0xF), b);
} while (bit_length);
} while ((i = -~i));
return buf;
}

string UTF8_SHA1(string plain) {
integer H1 = 0x67452301;
integer H2 = 0xefcdab89;
integer H3 = 0x98badcfe;
integer H4 = 0x10325476;
integer H5 = 0xc3d2e1f0;

//ORing on the extra bit. Since we are working in base64 the byte bounderies aren't where we want them.
//So we get the last byte group and append our extra bit onto it. It contains either 1, 2, or 3 bytes.
integer j = llSubStringIndex((plain = llStringToBase64(plain))+"=", "=");
integer T = 0x80000000;
if(j) {
j = (6 * (T = j)) & -8;//length in bits
T = llBase64ToInteger(llGetSubString((llGetSubString(plain, -4, (~-(T)))) + "AAAA", 0, 5)) | (0x00000080 << ((j % 3) << 3));
}
integer b = ((j + 40) >> 5) | 15;//this works because we want the value to be one less than the next appropriate multiple of 16.
string buf = "AAA";
integer i = -5;
do buf += buf; while((i = -~i));//We need 85, 96 is close enough
//llOwnerSay(llList2CSV([b,j, llStringLength(buf), llIntegerToBase64(j << (6 - ((b % 3) << 1)))]));
plain = llInsertString( llDeleteSubString(plain, -4, -1) +
llGetSubString(llIntegerToBase64(T), 0, 5) + buf, (b << 4) / 3,
llGetSubString(llIntegerToBase64(j >> ((b % 3) << 1)), 0, 5));
//llOwnerSay(llList2CSV([llStringLength(plain), Base64ToHex(plain)]));
list x;
integer S = 0;
do {
integer A = H1;
integer B = H2;
integer C = H3;
integer D = H4;
integer E = H5;
x = (list)(j = 0);//the zero gets flushed off the stack by the later loops
do {
T = llBase64ToInteger(buf = llGetSubString(plain, T = ((i + j) << 4) / 3, T+6)) << (S = ((i + j) % 3) << 1);
if(S)
T = T | (llBase64ToInteger("A" + (llDeleteSubString(buf, 0, 1))) >> (6 - S));
// llOwnerSay("W["+(string)j+"]="+hex(T));
x += T;
T += ((A << 5) | ((A >> 27) & 0x1F)) + (D ^ (B & (C ^ D))) + E + 0x5a827999;//k
E = D;
D = C;
C = ((B << 30) | ((B >> 2) & 0x3FFFFFFF));
B = A;
A = T;
} while(16 > (j = -~j));
// llOwnerSay(llList2CSV(hexm(x)));
do {
S = llList2Integer(x, -3) ^ llList2Integer(x, -8) ^ llList2Integer(x, -14) ^ llList2Integer(x, -16);
x = llList2List(x + (T = ((S << 1) | !!(S & 0x80000000))), -16, -1);
// llOwnerSay("W["+(string)j+"]="+hex(T));
T += ((A << 5) | ((A >> 27) & 0x1F)) + (D ^ (B & (C ^ D))) + E + 0x5a827999;//k
E = D;
D = C;
C = ((B << 30) | ((B >> 2) & 0x3FFFFFFF));
B = A;
A = T;
} while(20 > (j = -~j));
do {
S = llList2Integer(x, -3) ^ llList2Integer(x, -8) ^ llList2Integer(x, -14) ^ llList2Integer(x, -16);
x = llList2List(x + (T = ((S << 1) | !!(S & 0x80000000))), -16, -1);
// llOwnerSay("W["+(string)j+"]="+hex(T));
T += ((A << 5) | ((A >> 27) & 0x1F)) + (B ^ C ^ D) + E + 0x6ed9eba1;//k
E = D;
D = C;
C = ((B << 30) | ((B >> 2) & 0x3FFFFFFF));
B = A;
A = T;
} while(40 > (j = -~j));
do {
S = llList2Integer(x, -3) ^ llList2Integer(x, -8) ^ llList2Integer(x, -14) ^ llList2Integer(x, -16);
x = llList2List(x + (T = ((S << 1) | !!(S & 0x80000000))), -16, -1);
// llOwnerSay("W["+(string)j+"]="+hex(T));
T += ((A << 5) | ((A >> 27) & 0x1F)) + ((B & C) | (B & D) | (C & D)) + E + 0x8f1bbcdc;//k
E = D;
D = C;
C = ((B << 30) | ((B >> 2) & 0x3FFFFFFF));
B = A;
A = T;
} while(60 > (j = -~j));
do {
S = llList2Integer(x, -3) ^ llList2Integer(x, -8) ^ llList2Integer(x, -14) ^ llList2Integer(x, -16);
x = llList2List(x + (T = ((S << 1) | !!(S & 0x80000000))), -16, -1);
// llOwnerSay("W["+(string)j+"]="+hex(T));
T += ((A << 5) | ((A >> 27) & 0x1F)) + (B ^ C ^ D) + E + 0xca62c1d6;//k
E = D;
D = C;
C = ((B << 30) | ((B >> 2) & 0x3FFFFFFF));
B = A;
A = T;
} while(80 > (j = -~j));
H1 += A;
H2 += B;
H3 += C;
H4 += D;
H5 += E;
} while(b > (i += 16));
x = [H1, H2, H3, H4, H5];
i = -5;
buf = "";
do {
T = llList2Integer(x,i);
j = 32;
do {
buf += llGetSubString(hexc, b = ((T >> (j -= 4)) & 0xF), b);
} while (j);
} while ((i = -~i));
return buf;
}

integer go(string in, string answer) {
llOwnerSay("");
string b = llStringToBase64(in);
integer len = (6 * llSubStringIndex((b)+"=", "=")) & -8;
llResetTime();
string outu = UTF8_SHA1(in);
float tu = llGetTime();
llOwnerSay(llList2CSV(([outu, tu, len])));
llResetTime();
string outb = Base64_SHA1(b, len);
float tb = llGetTime();
llOwnerSay(llList2CSV(([outb, tb, len])));
if(answer) {
llOwnerSay(llList2CSV(([answer, (answer == outu),(answer == outb)])));
return (answer == outb) && (answer == outu);
}
return TRUE;
}

default
{
state_entry()
{
if(Base64_SHA1("AAAA", 24) != "29E2DCFBB16F63BB0254DF7585A15BB6FB5E927D")
llOwnerSay("Failed Base64_SHA1(\"AAAA\", 24)");
if(go("", "DA39A3EE5E6B4B0D3255BFEF95601890AFD80709"))
if(go("abc", "A9993E364706816ABA3E25717850C26C9CD0D89D"))
if(go("The quick brown fox jumps over the lazy dog", "2FD4E1C67A2D28FCED849EE1BB76E7391B93EB12"))
llOwnerSay("All Tests Passed!");
// llOwnerSay((string)llGetTime());
}
}</source>

{{LSLC|Library}}{{LSLC|Examples}}
[[Category: LSL Encryption]]