SkyLine
  • SkyLine | Introduction
    • Module Overview
    • SkyLine's Development
    • Skyline's Reason
    • SkyLine Syntax
    • SkyLine Concepts
      • Concepts | Modes
  • SkyLine | Technologies
    • Module Overview
    • REPL
      • REPL - Basic usage
      • REPL - Console Design
      • REPL - Commands
    • SLC
      • SLC - What is it
      • SLC - Use cases
      • SLC - Lexical Analysis
      • SLC - Intro To Development
      • SLC - Error System
  • SkyLine | Theory
    • Module Overview
    • Theory | Type Systems
      • Objects | Strings
      • Objects | Integers & Floats
  • SkyLine | Development
    • Module Overview
    • Development | Hello Integers?
  • SL | Hybrid Development
    • Module Overview
    • Hybrid Projects | Advancing
    • Hybrid Projects | Wrapping
    • Hybrid Projects | Using SLC
  • SkyLine | For Abusers
    • SL Abuser | Security Research
    • SL Abuser | Module Overview
    • SL Abuser | Abusing Helps
  • SkyLine Experiments
    • Introduction To Module
      • Caster - IoT Manipulation With SkyLine
        • Caster In Real World Scenarios
          • Cracking The Grounds
        • Caster: Setting Up
        • Caster - Running Caster
        • Caster - Dev Manipulation
          • Caster - Console
          • Caster - Apple Devs
          • Caster - Amazon Devs
          • Caster - Google Devs
          • Caster - Roku Devs
      • SkyNeXt - Hacking The Skies
      • SkyLine - PwnLib
Powered by GitBook
On this page
  1. SkyLine | For Abusers

SL Abuser | Abusing Helps

PreviousSL Abuser | Module OverviewNextIntroduction To Module

Last updated 1 year ago

SkyLine | For abusers -> Helpers

You may be asking why we are asking you to abuse the language in its usage such as trying to overflow data types, trying to remotely overflow or stop threads or generally mess around with the syntax and what the language can and cant do.

Well, we are asking you and telling you to do this because abusing the language helps us all understand how the language works, the problems with it, how specific systems will be affected and what issues are going to be chain issues to others.

  • Chain Issues: Chain issues within a programming language can be extremely dangerous, these are issues where if one prime issue is made or a bug is created, 10-20 other problems will occur. Trying to find or search for vulnerabilities or even bugs alike will help us better protect the language and make it a much more nicer experience for the users.

  • Error related issues: The error system within SkyLine is not the most accurate, it has some issues despite using a custom code system and initiation system. The error system might also get quite confused when looking for issues which means that some event such as a missing token event was not directly found and in that cause the parser or evaluation functions or compilation and execution functions failed to fully catch the error at runtime. We solve this issue by tracing the exact line where the interpreter or compiler stopped executing code and then iterating through the environment to find that line of code and match its tokens.

  • Standard Libraries: Standard libraries are another major target. Since SkyLine is not a self hosted programming language and is built using the Go programming language, we suggest that you test the standard libraries. This is because that most built in, registered, standard libraries are plugins written in Go or libraries on the backend embedded into the code. When a standard library is called to be registered into the environment, the functions that are thrown into the environment are all function calls that require SkyLine related data types. When the function or standard function is called, the standard library will take the parameters for that function and then convert them to native data types within the Go programming language. However, some of these data types do not exist in SkyLine, so the standard libraries will need to check an array that holds a 2 dimensional array. Since arrays are one giant type which means even [[[[[[[[[[]]]]]]]]]] is considered to still be a single array, the language will check and verify for two dimensions within the given array and attempt to convert it to [][]string slices. This can become a problem and understanding that the parameters work by converting the SL data types to Go data types will help better abuse it.