A C# SDK to access the Solcast API, allowing you to retrieve solar radiation, weather data, and forecasts from satellite and numerical models.

• Retrieve live solar radiation and weather data.
• Access forecast data up to 14 days in advance.
• Access Typical Meteorological Year (TMY) data for irradiance and rooftop PV power.
• Get live and forecast grid aggregation data.
• Manage PV Power Sites for advanced solar power modeling.
• Simple, easy-to-use client classes for API interaction.

• C# SDK documentation: https://solcast.github.io/solcast-api-csharp-sdk/
• Full API documentation available at: Solcast API Docs

Install the SDK via NuGet with the following command:

dotnet add package Solcast

Alternatively, you can build the SDK locally by cloning the repository and running the build command:

git clone https://github.com/Solcast/solcast-api-csharp-sdk.git
cd solcast-api-csharp-sdk
dotnet build

Before using the SDK, you need to set your Solcast API key as an environment variable. You can register for an API key at Solcast Toolkit.

To set the API key in your environment:

Windows PowerShell:

$env:SOLCAST_API_KEY = "{your_api_key}"

Linux/macOS:

export SOLCAST_API_KEY="{your_api_key}"

using Solcast.Clients;

var liveClient = new LiveClient();
var response = await liveClient.GetLiveRadiationAndWeather(
    latitude: -33.856784,
    longitude: 151.215297,
    outputParameters: ["air_temp", "dni", "ghi"]
    format: "csv"
);

Console.WriteLine(response.RawResponse);

using Solcast.Clients;

var forecastClient = new ForecastClient();
var response = await forecastClient.GetForecastRadiationAndWeather(
    latitude: -33.856784,
    longitude: 151.215297,
    outputParameters: ["air_temp", "dni", "ghi"]
);

using Solcast.Clients;

var historicClient = new HistoricClient();
var response = await historicClient.GetHistoricRadiationAndWeather(
    latitude: -33.856784,
    longitude: 151.215297,
    start: "2022-01-01T00:00",
    duration: "P1D"
);

using Solcast.Clients;

var tmyClient = new TmyClient();
var response = await tmyClient.GetTmyRadiationAndWeather(
    latitude: -33.856784,
    longitude: 151.215297,
);

using Solcast.Clients;

var aggregationClient = new AggregationClient();
var response = await aggregationClient.GetForecastAggregations(
    collectionId: "country_total",
    aggregationId: "it_total",
    outputParameters: ["percentage", "pv_estimate"],
    format: "csv"
);

using Solcast.Clients;

var pvClient = new PvPowerSiteClient();
var response = await pvClient.GetPvPowerSites();

using Solcast.Clients;

var pvClient = new PvPowerSiteClient();
var response = await pvClient.GetPvPowerSite("ba75-e17a-7374-95ed");

• GetLiveRadiationAndWeather: Retrieves live solar radiation and weather data.
• GetLiveAdvancedPvPower: Retrieves advanced PV power live data.
• GetLiveRooftopPvPower: Retrieves live rooftop PV power data based on location and other parameters.

• GetForecastRadiationAndWeather: Retrieves irradiance and weather forecasts for the requested location from the present up to 14 days ahead
• GetForecastAdvancedPvPower: Retrieves advanced PV power forecasts with customizable options.
• GetForecastRooftopPvPower: Retrieves rooftop PV power forecast data based on location and other parameters.

• GetHistoricRadiationAndWeather: Retrieves historic solar radiation and weather data for a specified time range.
• GetHistoricAdvancedPvPower: Retrieves advanced PV power historical data.
• GetHistoricRooftopPvPower: Retrieves rooftop PV power historical data.

• GetTmyRadiationAndWeather: Retrieves TMY irradiance and weather data for a specified location.
• GetTmyAdvancedPvPower: Retrieves advanced PV power TMY data.
• GetTmyRooftopPvPower: Retrieves TMY rooftop PV power data.

• GetLiveAggregations: Retrieves live grid aggregation data for up to 7 days.
• GetForecastAggregations: Retrieves forecast grid aggregation data for up to 7 days.

• GetPvPowerSites: Retrieves a list of all available PV power sites.
• GetPvPowerSite: Retrieves metadata for a specific PV power site by its resource ID.
• PostPvPowerSite: Creates a new PV Power Site for use with advanced PV power model.
• PatchPvPowerSite: Partially updates the specifications of an existing PV power site.
• PutPvPowerSite: Overwrites an existing PV power site specifications.
• DeletePvPowerSite: Deletes an existing PV power site.

By default, the SDK does not check for updates during runtime. To enable automatic update checking, you can pass true for the checkForUpdates parameter when creating client instances:

var liveClient = new LiveClient(checkForUpdates: true);

Alternatively, to enable update checking automatically for all client instances, set the CHECK_SDK_UPDATE environment variable to true:

Windows PowerShell:

$env:CHECK_SDK_UPDATE = "true"

Linux/macOS:

export CHECK_SDK_UPDATE="true"

When this flag is set, the SDK will automatically check for new versions during runtime regardless of the checkForUpdates parameter value.

To run the tests, use the following command:

dotnet build && dotnet test

Live:

dotnet run --project examples/Solcast.Examples/Solcast.Examples.csproj live

Historic:

dotnet run --project examples/Solcast.Examples/Solcast.Examples.csproj historic

Forecast:

dotnet run --project examples/Solcast.Examples/Solcast.Examples.csproj forecast

This SDK is licensed under the Apache 2.0 License. See the LICENSE file for more information.

Link to PPT: https://docs.google.com/presentation/d/18IkCE0zR9xVpruWyxMjxytwgpBg7m3-IpwAkUm5MSd0/edit?usp=sharing

About 1/3 of food produced in the world is lost or wasted in the year. There are many reasons for this, including not being able to cook with said food, not having time to cook this food or cooking food that does not taste good. Albeit this, food waste is a serious problem that wastes money, wastes time and harms the environment.

Our web app, Recipe Nest is a chat bot deployed on Slack, the Web, through calls. (Messenger and Google Assistant are currently awaiting approval). Users simply enter in all the filters they would like their recipe to contain and Recipe Nest finds a recipe conforming to the users’ requests! We believe that making this application as accessible as possible reflects our goal of making it easy to get started with cooking at home and not wasting food!

We used Python, Flask, for the backend. Our chat bot was built with Google Cloud’s Dialogflow in which we personally trained to be able to take user input. The front end was built with CSS, HTML, and Bootstrap.

We hope to add user logins via Firebase. We would then add features such as 1. Saving food in your fridge 2. Having the app remind you of this food 3. Allow the user to save recipes that they like. Additionally, we would like to add more filters, such as nutrition, cost, and excluding certain foods, and finally, create a better UI/UX experience for the user.

Link to PPT: https://docs.google.com/presentation/d/18IkCE0zR9xVpruWyxMjxytwgpBg7m3-IpwAkUm5MSd0/edit?usp=sharing

About 1/3 of food produced in the world is lost or wasted in the year. There are many reasons for this, including not being able to cook with said food, not having time to cook this food or cooking food that does not taste good. Albeit this, food waste is a serious problem that wastes money, wastes time and harms the environment.

Our web app, Recipe Nest is a chat bot deployed on Slack, the Web, through calls. (Messenger and Google Assistant are currently awaiting approval). Users simply enter in all the filters they would like their recipe to contain and Recipe Nest finds a recipe conforming to the users’ requests! We believe that making this application as accessible as possible reflects our goal of making it easy to get started with cooking at home and not wasting food!

We used Python, Flask, for the backend. Our chat bot was built with Google Cloud’s Dialogflow in which we personally trained to be able to take user input. The front end was built with CSS, HTML, and Bootstrap.

We hope to add user logins via Firebase. We would then add features such as 1. Saving food in your fridge 2. Having the app remind you of this food 3. Allow the user to save recipes that they like. Additionally, we would like to add more filters, such as nutrition, cost, and excluding certain foods, and finally, create a better UI/UX experience for the user.

hrr_rb_ssh is a pure Ruby SSH 2.0 server and client implementation.

With hrr_rb_ssh, it is possible to write an SSH server easily, and also possible to write an original server side application on secure connection provided by SSH protocol. And it supports to write SSH client as well.

NOTE: ED25519 public key algorithm is now separated from hrr_rb_ssh. Please refer to hrr_rb_ssh-ed25519.

• Installation
• Usage
  • Requiring hrr_rb_ssh library
  • Logging
  • Writing standard SSH server
    • Starting server application
    • Registering pre-generated secret keys for server host key
    • Defining authentications
      • Single authentication
        • Password authentication
        • Publickey authentication
        • Keyboard-interactive authentication
        • None authentication (NOT recomended)
      • Multi-step authentication
      • More flexible authentication
    • Handling session channel requests
      • Reference request handlers
      • Custom request handlers
    • Defining preferred algorithms (optional)
    • Hiding and/or simulating local SSH version
  • Writing SSH client (Experimental)
    • Starting SSH connection
    • Executing remote commands
      • exec method
      • shell method
      • subsystem method
  • Demo
• Supported Features
  • Connection layer
  • Authentication layer
  • Transport layer
• Contributing
• Code of Conduct
• License

Add this line to your application’s Gemfile:

gem 'hrr_rb_ssh'

And then execute:

$ bundle

Or install it yourself as:

$ gem install hrr_rb_ssh

First of all, hrr_rb_ssh library needs to be loaded.

require 'hrr_rb_ssh'

IMPORTANT: DEBUG log level outputs all communications between local and remote in human-readable plain-text including password and any secret. Be careful to use logging.

The library provides logging functionality. To enable logging in the library, you are to give a logger to Server.new or Client.new.

HrrRbSsh::Server.new options, logger: logger

or

HrrRbSsh::Client.new target, options, logger: logger

Where, the logger variable can be an instance of standard Logger class or user-defined logger class. What the library requires for logger variable is that the logger instance responds to #fatal, #error, #warn, #info and #debug with the following syntax.

logger.fatal(progname){ message }
logger.error(progname){ message }
logger.warn(progname){ message }
logger.info(progname){ message }
logger.debug(progname){ message }

For instance, logger variable can be prepared like below.

logger = Logger.new STDOUT
logger.level = Logger::INFO

The library is to run on a socket IO. To start SSH server, running a server IO and accepting a connection are required. The 10022 port number is just an example.

options = Hash.new
server = TCPServer.new 10022
loop do
  Thread.new(server.accept) do |io|
    pid = fork do
      begin
        server = HrrRbSsh::Server.new options
        server.start io
      ensure
        io.close
      end
    end
    io.close
    Process.waitpid pid
  end
end

Where, an options variable is an instance of Hash, which has optional (or sometimes almost necessary) values.

By default, server host keys are generated everytime the gem is loaded. To use pre-generated keys, it is possible to register the keys in HrrRbSsh::Transport through options variable. The secret key value must be PEM or DER format string. The below is an example of registering ecdsa-sha2-nistp256 secret key. The supported server host key algorithms are listed later in this document.

options['transport_server_secret_host_keys'] = {}
options['transport_server_secret_host_keys']['ecdsa-sha2-nistp256'] = <<-'EOB'
-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIFFtGZHk6A8anZkLCJan9YBlB63uCIN/ZcQNCaJout8loAoGCCqGSM49
AwEHoUQDQgAEk8m548Xga+XGEmRx7P71xGlxCfgjPj3XVOw+fXPXRgA03a5yDJEp
OfeosJOO9twerD7pPhmXREkygblPsEXaVA==
-----END EC PRIVATE KEY-----
EOB

By default, any authentications get failed. To allow users to login to the SSH service, at least one of the authentication methods must be defined and registered into the instance of HrrRbSsh::Authentication through options variable.

The library defines a sort of strategies to implement handling authentication.

Each authenticator returns true (or HrrRbSsh::Authentication::SUCCESS) or false (or HrrRbSsh::Authentication::FAILURE). When it is true, the user is accepted. When it is false, the user is not accepted and a subsequent authenticator is called.

Password authentication is the most simple way to allow users to login to the SSH service. Password authentication requires user-name and password.

To define a password authentication, the HrrRbSsh::Authentication::Authenticator.new { |context| ... } block is used. When the block returns true, then the authentication succeeded.

auth_password = HrrRbSsh::Authentication::Authenticator.new { |context|
  user_and_pass = [
    ['user1',  'password1'],
    ['user2',  'password2'],
  ]
  user_and_pass.any? { |user, pass|
    context.verify user, pass
  }
}
options['authentication_password_authenticator'] = auth_password

The context variable in password authentication context provides the followings.

• #username : The username that a remote user tries to authenticate
• #password : The password that a remote user tries to authenticate
• #variables : A hash instance that is shared in each authenticator and subsequent session channel request handlers
• #vars : The same object that #variables returns
• #verify(username, password) : Returns true when username and password arguments match with the context’s username and password. Or returns false when username and password arguments don’t match.

The second one is public key authentication. Public key authentication requires user-name, public key algorithm name, and PEM or DER formed public key.

To define a public key authentication, the HrrRbSsh::Authentication::Authenticator.new { |context| ... } block is used as well. When the block returns true, then the authentication succeeded as well. However, context variable behaves differently.

auth_publickey = HrrRbSsh::Authentication::Authenticator.new { |context|
  username = ENV['USER']
  authorized_keys = HrrRbSsh::Compat::OpenSSH::AuthorizedKeys.new(File.read(File.join(Dir.home, '.ssh', 'authorized_keys')))
  authorized_keys.any?{ |public_key|
    context.verify username, public_key.algorithm_name, public_key.to_pem
  }
}
options['authentication_publickey_authenticator'] = auth_publickey

The context variable in public key authentication context provides the #verify method. The #verify method takes three arguments; username, public key algorithm name and PEM or DER formed public key.

And public keys that is in OpenSSH public key format is now available. To use OpenSSH public keys, it is easy to use $USER_HOME/.ssh/authorized_keys file.

The third one is keyboard-interactive authentication. This is also known as challenge-response authentication.

To define a keyboard-interactive authentication, the HrrRbSsh::Authentication::Authenticator.new { |context| ... } block is used as well. When the block returns true, then the authentication succeeded as well. However, context variable behaves differently.

auth_keyboard_interactive = HrrRbSsh::Authentication::Authenticator.new { |context|
  user_name        = 'user1'
  req_name         = 'demo keyboard interactive authentication'
  req_instruction  = 'demo instruction'
  req_language_tag = ''
  req_prompts = [
    #[prompt[n], echo[n]]
    ['Password1: ', false],
    ['Password2: ', true],
  ]
  info_response = context.info_request req_name, req_instruction, req_language_tag, req_prompts
  context.username == user_name && info_response.responses == ['password1', 'password2']
}
options['authentication_keyboard_interactive_authenticator'] = auth_keyboard_interactive

The context variable in keyboard-interactive authentication context does NOT provides the #verify method. Instead, #info_request method is available. Since keyboard-interactive authentication has multiple times interactions between server and client, the values in responses needs to be verified respectively.

The #info_request method takes four arguments: name, instruction, language tag, and prompts. The name, instruction, and language tag can be empty string. The prompts needs to have at least one charactor for prompt message, and true or false value to specify whether echo back is enabled or not.

The responses are listed in the same order as request prompts.

The last one is none authentication. None authentication is usually NOT used.

To define a none authentication, the HrrRbSsh::Authentication::Authenticator.new { |context| ... } block is used as well. When the block returns true, then the authentication succeeded as well. However, context variable behaves differently.

auth_none = HrrRbSsh::Authentication::Authenticator.new { |context|
  if context.username == 'user1'
    true
  else
    false
  end
}
options['authentication_none_authenticator'] = auth_none

In none authentication context, context variable provides the #username method.

In this strategy that conbines single authentications, it is possible to implement multi-step authentication. In case that the combination is a publickey authentication method and a password authentication method, it is so-called two-factor authentication.

A return value of each authentication handler can be HrrRbSsh::Authentication::PARTIAL_SUCCESS. The value means that the authentication method returns success and another authenticatoin method is requested (i.e. the authentication method is deleted from the list of authentication that can continue, and then the server sends USERAUTH_FAILURE message with the updated list of authentication that can continue and partial success true). When all preferred authentication methods returns PARTIAL_SUCCESS (i.e. there is no more authentication that can continue), then the user is treated as authenticated.

auth_preferred_authentication_methods = ["publickey", "password"]
auth_publickey = HrrRbSsh::Authentication::Authenticator.new { |context|
  is_verified = some_verification_method(context)
  if is_verified
    HrrRbSsh::Authentication::PARTIAL_SUCCESS
  else
    false
  end
}
auth_password = HrrRbSsh::Authentication::Authenticator.new { |context|
  is_verified = some_verification_method(context)
  if is_verified
    HrrRbSsh::Authentication::PARTIAL_SUCCESS
  else
    false
  end
}
options['authentication_preferred_authentication_methods'] = auth_preferred_authentication_methods
options['authentication_publickey_authenticator'] = auth_publickey
options['authentication_password_authenticator'] = auth_password

A context variable in an authenticator gives an access to remaining authentication methods that can continue. In this strategy, an implementer is able to control the order of authentication methods and to control which authentication methods are used for the user.

The below is an example. It is expected that any user must be verified by publickey and then another authentication is requested for the user accordingly.

auth_preferred_authentication_methods = ['none']
auth_none = HrrRbSsh::Authentication::Authenticator.new{ |context|
  context.authentication_methods.push 'publickey'
  HrrRbSsh::Authentication::PARTIAL_SUCCESS
}
auth_publickey = HrrRbSsh::Authentication::Authenticator.new{ |context|
  if some_verification(context)
    case context.username
    when 'user1'
      context.authentiation_methods.push 'keyboard-interactive'
      HrrRbSsh::Authentication::PARTIAL_SUCCESS
    else
      false
    end
  else
    false
  end
}
auth_keyboard_interactive = HrrRbSsh::Authentication::Authenticator.new{ |context|
  if some_verification(context)
    true # or HrrRbSsh::Authentication::PARTIAL_SUCCESS; both will accept the user because remaining authentication method is only 'keyboard-interactive' in this case
  else
    false
  end
}
options['authentication_preferred_authentication_methods'] = auth_preferred_authentication_methods
options['authentication_none_authenticator'] = auth_none
options['authentication_publickey_authenticator'] = auth_publickey
options['authentication_keyboard_interactive_authenticator'] = auth_keyboard_interactive

By default, any channel requests belonging to session channel are implicitly ignored. To handle the requests, defining request handlers are required.

There are pre-implemented request handlers available for reference as below.

options['connection_channel_request_pty_req']       = HrrRbSsh::Connection::RequestHandler::ReferencePtyReqRequestHandler.new
options['connection_channel_request_env']           = HrrRbSsh::Connection::RequestHandler::ReferenceEnvRequestHandler.new
options['connection_channel_request_shell']         = HrrRbSsh::Connection::RequestHandler::ReferenceShellRequestHandler.new
options['connection_channel_request_exec']          = HrrRbSsh::Connection::RequestHandler::ReferenceExecRequestHandler.new
options['connection_channel_request_window_change'] = HrrRbSsh::Connection::RequestHandler::ReferenceWindowChangeRequestHandler.new

It is also possible to define customized request handlers. For instance, echo server can be implemented very easily as below. In this case, echo server works instead of shell and PTY-req and env requests are undefined.

conn_echo = HrrRbSsh::Connection::RequestHandler.new { |context|
  context.chain_proc { |chain|
    begin
      loop do
        buf = context.io[0].readpartial(10240)
        break if buf.include?(0x04.chr) # break if ^D
        context.io[1].write buf
      end
      exitstatus = 0
    rescue => e
      logger.error([e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join)
      exitstatus = 1
    end
    exitstatus
  }
}
options['connection_channel_request_shell'] = conn_echo

In HrrRbSsh::Connection::RequestHandler.new block, context variable basically provides the followings.

• #io => [in, out, err] : in is readable and read data is sent by remote. out and err are writable. out is for standard output and written data is sent as channel data. err is for standard error and written data is sent as channel extended data.
• #chain_proc => {|chain| ... } : When a session channel is opened, a background thread is started and is waitng for a chained block registered. This #chain_proc is used to define how to handle subsequent communications between local and remote. The chain variable provides #call_next method. In #proc_chain block, it is possible to call subsequent block that is defined in another request handler. For instance, shell request must called after pty-req request. The chain in pty-req request handler’s #chain_proc calls #next_proc and then subsequent shell request handler’s #chain_proc will be called.
• #close_session : In most cases, input and output between a client and the server is handled in #chain_proc and closing the #chain_proc block will lead closing the underlying session channel. This means that to close the underlying session channel it is required to write at least one #chain_proc block. If it is not required to use #chain_proc block or is required to close the underlying session channel from outside of #chain_proc block, #close_session can be used. The #close_session will close the background thread that calls #chain_proc blocks.
• #variables => Hash : A hash instance that is passed from authenticator and is shared in subsequent session channel request handlers
• #vars : The same object that #variables returns

And request handler’s context variable also provides additional methods based on request type. See lib/hrr_rb_ssh/connection/channel/channel_type/session/request_type/<request type>/context.rb.

Preferred encryption, server-host-key, KEX and compression algorithms can be selected and defined.

options['transport_preferred_encryption_algorithms']      = %w(aes256-ctr aes128-cbc)
options['transport_preferred_server_host_key_algorithms'] = %w(ecdsa-sha2-nistp256 ssh-rsa)
options['transport_preferred_kex_algorithms']             = %w(ecdh-sha2-nistp256 diffie-hellman-group14-sha1)
options['transport_preferred_mac_algorithms']             = %w(hmac-sha2-256 hmac-sha1)
options['transport_preferred_compression_algorithms']     = %w(none)

Supported algorithms can be got with each algorithm class’s #list_supported method, and default preferred algorithms can be got with each algorithm class’s #list_preferred method.

Outputs of #list_preferred method are ordered as preferred; i.e. the name listed at head is used as most preferred, and the name listed at tail is used as non-preferred.

p HrrRbSsh::Transport::EncryptionAlgorithm.list_supported
# => ["none", "3des-cbc", "blowfish-cbc", "aes128-cbc", "aes192-cbc", "aes256-cbc", "arcfour", "cast128-cbc", "aes128-ctr", "aes192-ctr", "aes256-ctr"]
p HrrRbSsh::Transport::EncryptionAlgorithm.list_preferred
# => ["aes128-ctr", "aes192-ctr", "aes256-ctr", "aes128-cbc", "3des-cbc", "blowfish-cbc", "cast128-cbc", "aes192-cbc", "aes256-cbc", "arcfour"]

p HrrRbSsh::Transport::ServerHostKeyAlgorithm.list_supported
# => ["ssh-dss", "ssh-rsa", "ecdsa-sha2-nistp256", "ecdsa-sha2-nistp384", "ecdsa-sha2-nistp521"]
p HrrRbSsh::Transport::ServerHostKeyAlgorithm.list_preferred
# => ["ecdsa-sha2-nistp521", "ecdsa-sha2-nistp384", "ecdsa-sha2-nistp256", "ssh-rsa", "ssh-dss"]

p HrrRbSsh::Transport::KexAlgorithms.new.list_supported
# => ["diffie-hellman-group1-sha1", "diffie-hellman-group14-sha1", "diffie-hellman-group-exchange-sha1", "diffie-hellman-group-exchange-sha256", "diffie-hellman-group14-sha256", "diffie-hellman-group15-sha512", "diffie-hellman-group16-sha512", "diffie-hellman-group17-sha512", "diffie-hellman-group18-sha512", "ecdh-sha2-nistp256", "ecdh-sha2-nistp384", "ecdh-sha2-nistp521"]
p HrrRbSsh::Transport::KexAlgorithms.new.list_preferred
# => ["ecdh-sha2-nistp521", "ecdh-sha2-nistp384", "ecdh-sha2-nistp256", "diffie-hellman-group18-sha512", "diffie-hellman-group17-sha512", "diffie-hellman-group16-sha512", "diffie-hellman-group15-sha512", "diffie-hellman-group14-sha256", "diffie-hellman-group-exchange-sha256", "diffie-hellman-group-exchange-sha1", "diffie-hellman-group14-sha1", "diffie-hellman-group1-sha1"]

p HrrRbSsh::Transport::MacAlgorithm.list_supported
# => ["none", "hmac-sha1", "hmac-sha1-96", "hmac-md5", "hmac-md5-96", "hmac-sha2-256", "hmac-sha2-512"]
p HrrRbSsh::Transport::MacAlgorithm.list_preferred
# => ["hmac-sha2-512", "hmac-sha2-256", "hmac-sha1", "hmac-md5", "hmac-sha1-96", "hmac-md5-96"]

p HrrRbSsh::Transport::CompressionAlgorithm.list_supported
# => ["none", "zlib"]
p HrrRbSsh::Transport::CompressionAlgorithm.list_preferred
# => ["none", "zlib"]

By default, hrr_rb_ssh sends SSH-2.0-HrrRbSsh-#{VERSION} string at initial negotiation with remote peer. To address security concerns, it is possible to replace the version string.

# Hiding version
options['local_version'] = "SSH-2.0-HrrRbSsh"

# Simulating OpenSSH
options['local_version'] = "SSH-2.0-OpenSSH_x.x"

# Simulating OpenSSH and hiding version
options['local_version'] = "SSH-2.0-OpenSSH"

Please note that the beginning of the string must be SSH-2.0-. Otherwise SSH 2.0 remote peer cannot continue negotiation with the local peer.

The client mode can be started with HrrRbSsh::Client.start. The method takes target and options arguments. The target that the SSH client connects to can be one of:

• (IO) An io that is open for input and output
• (Array) An array of the target host address or host name and its service port number
• (String) The target host address or host name; in this case the target service port number will be 22

And the options contains various parameters for the SSH connection. At least username key must be set in the options. Also at least one of password, publickey, or keyboard-interactive needs to be set for authentication instead of authenticators that are used in server mode. Also as similar to server mode, it is possible to specify preferred transport algorithms and preferred authentication methods with the same keywords.

target = ['remotehost', 22]
options = {
  username: 'user1',
  password: 'password1',
  publickey: ['ssh-rsa', "/home/user1/.ssh/id_rsa")],
  authentication_preferred_authentication_methods = ['publickey', 'password'],
}
HrrRbSsh::Client.start(target, options) do |conn|
  # Do something here
  # For instance: conn.exec "command"
end

There are some methods supported in client mode. The methods works as a receiver of conn block variable.

The exec and exec! methods execute command on a remote host. Both takes a command argument that is executed in the remote host. And they can take optional pty and env arguments. When pty: true is set, then the command will be executed on a pseudo-TTY. When env: {'key' => 'value'} is set, then the environmental variables are set before the command is executed.

The exec! method returns [stdout, stderr] outputs. Once the command is executed and the outputs are completed, then the method returns the value.

conn.exec! "command" # => [stdout, stderr]

On the other hand, exec method takes block like the below example and returns exit status of the command. When the command is executed and the outputs and reading them are finished, then io_out and io_err return EOF.

conn.exec "command" do |io_in, io_out, io_err|
  # Do something here
end

The shell method provides a shell access on a remote host. As similar to exec method, it takes block and its block variable is also io_in, io_out, io_err. shell is always on pseudo-TTY, so it doesn’t take pty optional argument. It takes env optional argument. Exiting shell will leads io_out and io_err EOF.

conn.shell do |io_in, io_out, io_err|
  # Do something here
end

The subsystem method is to start a subsystem on a remote host. The method takes a subsystem name argument and a block. Its block variable is also io_in, io_out, io_err. subsystem doesn’t take pty nor env optional argument.

conn.subsystem("echo") do |io_in, io_out, io_err|
  # Do something here
end

The demo/server.rb shows a good example on how to use the hrr_rb_ssh library in SSH server mode. And the demo/client.rb shows an example on how to use the hrr_rb_ssh library in SSH client mode.

The following features are currently supported.

• Session channel
  • Shell (PTY-req, env, shell, window-change) request
  • Exec request
  • Subsystem request
• Local port forwarding (direct-tcpip channel)
• Remote port forwarding (tcpip-forward global request and forwarded-tcpip channel)

• None authentication
• Password authentication
• Public key authentication
  • ssh-dss
  • ssh-rsa
  • ecdsa-sha2-nistp256
  • ecdsa-sha2-nistp384
  • ecdsa-sha2-nistp521
• Keyboard interactive (generic interactive / challenge response) authentication

• Encryption algorithm
  • none
  • 3des-cbc
  • blowfish-cbc
  • aes128-cbc
  • aes192-cbc
  • aes256-cbc
  • arcfour
  • cast128-cbc
  • aes128-ctr
  • aes192-ctr
  • aes256-ctr
• Server host key algorithm
  • ssh-dss
  • ssh-rsa
  • ecdsa-sha2-nistp256
  • ecdsa-sha2-nistp384
  • ecdsa-sha2-nistp521
• Kex algorithm
  • diffie-hellman-group1-sha1
  • diffie-hellman-group14-sha1
  • diffie-hellman-group-exchange-sha1
  • diffie-hellman-group-exchange-sha256
  • diffie-hellman-group14-sha256
  • diffie-hellman-group15-sha512
  • diffie-hellman-group16-sha512
  • diffie-hellman-group17-sha512
  • diffie-hellman-group18-sha512
  • ecdh-sha2-nistp256
  • ecdh-sha2-nistp384
  • ecdh-sha2-nistp521
• Mac algorithm
  • none
  • hmac-sha1
  • hmac-sha1-96
  • hmac-md5
  • hmac-md5-96
  • hmac-sha2-256
  • hmac-sha2-512
• Compression algorithm
  • none
  • zlib

Bug reports and pull requests are welcome on GitHub at https://github.com/hirura/hrr_rb_ssh. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.

Everyone interacting in the HrrRbSsh project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the code of conduct.

The gem is available as open source under the terms of the Apache License 2.0.

hrr_rb_ssh is a pure Ruby SSH 2.0 server and client implementation.

With hrr_rb_ssh, it is possible to write an SSH server easily, and also possible to write an original server side application on secure connection provided by SSH protocol. And it supports to write SSH client as well.

NOTE: ED25519 public key algorithm is now separated from hrr_rb_ssh. Please refer to hrr_rb_ssh-ed25519.

• Installation
• Usage
  • Requiring hrr_rb_ssh library
  • Logging
  • Writing standard SSH server
    • Starting server application
    • Registering pre-generated secret keys for server host key
    • Defining authentications
      • Single authentication
        • Password authentication
        • Publickey authentication
        • Keyboard-interactive authentication
        • None authentication (NOT recomended)
      • Multi-step authentication
      • More flexible authentication
    • Handling session channel requests
      • Reference request handlers
      • Custom request handlers
    • Defining preferred algorithms (optional)
    • Hiding and/or simulating local SSH version
  • Writing SSH client (Experimental)
    • Starting SSH connection
    • Executing remote commands
      • exec method
      • shell method
      • subsystem method
  • Demo
• Supported Features
  • Connection layer
  • Authentication layer
  • Transport layer
• Contributing
• Code of Conduct
• License

Add this line to your application’s Gemfile:

gem 'hrr_rb_ssh'

And then execute:

$ bundle

Or install it yourself as:

$ gem install hrr_rb_ssh

First of all, hrr_rb_ssh library needs to be loaded.

require 'hrr_rb_ssh'

IMPORTANT: DEBUG log level outputs all communications between local and remote in human-readable plain-text including password and any secret. Be careful to use logging.

The library provides logging functionality. To enable logging in the library, you are to give a logger to Server.new or Client.new.

HrrRbSsh::Server.new options, logger: logger

or

HrrRbSsh::Client.new target, options, logger: logger

Where, the logger variable can be an instance of standard Logger class or user-defined logger class. What the library requires for logger variable is that the logger instance responds to #fatal, #error, #warn, #info and #debug with the following syntax.

logger.fatal(progname){ message }
logger.error(progname){ message }
logger.warn(progname){ message }
logger.info(progname){ message }
logger.debug(progname){ message }

For instance, logger variable can be prepared like below.

logger = Logger.new STDOUT
logger.level = Logger::INFO

The library is to run on a socket IO. To start SSH server, running a server IO and accepting a connection are required. The 10022 port number is just an example.

options = Hash.new
server = TCPServer.new 10022
loop do
  Thread.new(server.accept) do |io|
    pid = fork do
      begin
        server = HrrRbSsh::Server.new options
        server.start io
      ensure
        io.close
      end
    end
    io.close
    Process.waitpid pid
  end
end

Where, an options variable is an instance of Hash, which has optional (or sometimes almost necessary) values.

By default, server host keys are generated everytime the gem is loaded. To use pre-generated keys, it is possible to register the keys in HrrRbSsh::Transport through options variable. The secret key value must be PEM or DER format string. The below is an example of registering ecdsa-sha2-nistp256 secret key. The supported server host key algorithms are listed later in this document.

options['transport_server_secret_host_keys'] = {}
options['transport_server_secret_host_keys']['ecdsa-sha2-nistp256'] = <<-'EOB'
-----BEGIN EC PRIVATE KEY-----
MHcCAQEEIFFtGZHk6A8anZkLCJan9YBlB63uCIN/ZcQNCaJout8loAoGCCqGSM49
AwEHoUQDQgAEk8m548Xga+XGEmRx7P71xGlxCfgjPj3XVOw+fXPXRgA03a5yDJEp
OfeosJOO9twerD7pPhmXREkygblPsEXaVA==
-----END EC PRIVATE KEY-----
EOB

By default, any authentications get failed. To allow users to login to the SSH service, at least one of the authentication methods must be defined and registered into the instance of HrrRbSsh::Authentication through options variable.

The library defines a sort of strategies to implement handling authentication.

Each authenticator returns true (or HrrRbSsh::Authentication::SUCCESS) or false (or HrrRbSsh::Authentication::FAILURE). When it is true, the user is accepted. When it is false, the user is not accepted and a subsequent authenticator is called.

Password authentication is the most simple way to allow users to login to the SSH service. Password authentication requires user-name and password.

To define a password authentication, the HrrRbSsh::Authentication::Authenticator.new { |context| ... } block is used. When the block returns true, then the authentication succeeded.

auth_password = HrrRbSsh::Authentication::Authenticator.new { |context|
  user_and_pass = [
    ['user1',  'password1'],
    ['user2',  'password2'],
  ]
  user_and_pass.any? { |user, pass|
    context.verify user, pass
  }
}
options['authentication_password_authenticator'] = auth_password

The context variable in password authentication context provides the followings.

• #username : The username that a remote user tries to authenticate
• #password : The password that a remote user tries to authenticate
• #variables : A hash instance that is shared in each authenticator and subsequent session channel request handlers
• #vars : The same object that #variables returns
• #verify(username, password) : Returns true when username and password arguments match with the context’s username and password. Or returns false when username and password arguments don’t match.

The second one is public key authentication. Public key authentication requires user-name, public key algorithm name, and PEM or DER formed public key.

To define a public key authentication, the HrrRbSsh::Authentication::Authenticator.new { |context| ... } block is used as well. When the block returns true, then the authentication succeeded as well. However, context variable behaves differently.

auth_publickey = HrrRbSsh::Authentication::Authenticator.new { |context|
  username = ENV['USER']
  authorized_keys = HrrRbSsh::Compat::OpenSSH::AuthorizedKeys.new(File.read(File.join(Dir.home, '.ssh', 'authorized_keys')))
  authorized_keys.any?{ |public_key|
    context.verify username, public_key.algorithm_name, public_key.to_pem
  }
}
options['authentication_publickey_authenticator'] = auth_publickey

The context variable in public key authentication context provides the #verify method. The #verify method takes three arguments; username, public key algorithm name and PEM or DER formed public key.

And public keys that is in OpenSSH public key format is now available. To use OpenSSH public keys, it is easy to use $USER_HOME/.ssh/authorized_keys file.

The third one is keyboard-interactive authentication. This is also known as challenge-response authentication.

To define a keyboard-interactive authentication, the HrrRbSsh::Authentication::Authenticator.new { |context| ... } block is used as well. When the block returns true, then the authentication succeeded as well. However, context variable behaves differently.

auth_keyboard_interactive = HrrRbSsh::Authentication::Authenticator.new { |context|
  user_name        = 'user1'
  req_name         = 'demo keyboard interactive authentication'
  req_instruction  = 'demo instruction'
  req_language_tag = ''
  req_prompts = [
    #[prompt[n], echo[n]]
    ['Password1: ', false],
    ['Password2: ', true],
  ]
  info_response = context.info_request req_name, req_instruction, req_language_tag, req_prompts
  context.username == user_name && info_response.responses == ['password1', 'password2']
}
options['authentication_keyboard_interactive_authenticator'] = auth_keyboard_interactive

The context variable in keyboard-interactive authentication context does NOT provides the #verify method. Instead, #info_request method is available. Since keyboard-interactive authentication has multiple times interactions between server and client, the values in responses needs to be verified respectively.

The #info_request method takes four arguments: name, instruction, language tag, and prompts. The name, instruction, and language tag can be empty string. The prompts needs to have at least one charactor for prompt message, and true or false value to specify whether echo back is enabled or not.

The responses are listed in the same order as request prompts.

The last one is none authentication. None authentication is usually NOT used.

To define a none authentication, the HrrRbSsh::Authentication::Authenticator.new { |context| ... } block is used as well. When the block returns true, then the authentication succeeded as well. However, context variable behaves differently.

auth_none = HrrRbSsh::Authentication::Authenticator.new { |context|
  if context.username == 'user1'
    true
  else
    false
  end
}
options['authentication_none_authenticator'] = auth_none

In none authentication context, context variable provides the #username method.

In this strategy that conbines single authentications, it is possible to implement multi-step authentication. In case that the combination is a publickey authentication method and a password authentication method, it is so-called two-factor authentication.

A return value of each authentication handler can be HrrRbSsh::Authentication::PARTIAL_SUCCESS. The value means that the authentication method returns success and another authenticatoin method is requested (i.e. the authentication method is deleted from the list of authentication that can continue, and then the server sends USERAUTH_FAILURE message with the updated list of authentication that can continue and partial success true). When all preferred authentication methods returns PARTIAL_SUCCESS (i.e. there is no more authentication that can continue), then the user is treated as authenticated.

auth_preferred_authentication_methods = ["publickey", "password"]
auth_publickey = HrrRbSsh::Authentication::Authenticator.new { |context|
  is_verified = some_verification_method(context)
  if is_verified
    HrrRbSsh::Authentication::PARTIAL_SUCCESS
  else
    false
  end
}
auth_password = HrrRbSsh::Authentication::Authenticator.new { |context|
  is_verified = some_verification_method(context)
  if is_verified
    HrrRbSsh::Authentication::PARTIAL_SUCCESS
  else
    false
  end
}
options['authentication_preferred_authentication_methods'] = auth_preferred_authentication_methods
options['authentication_publickey_authenticator'] = auth_publickey
options['authentication_password_authenticator'] = auth_password

A context variable in an authenticator gives an access to remaining authentication methods that can continue. In this strategy, an implementer is able to control the order of authentication methods and to control which authentication methods are used for the user.

The below is an example. It is expected that any user must be verified by publickey and then another authentication is requested for the user accordingly.

auth_preferred_authentication_methods = ['none']
auth_none = HrrRbSsh::Authentication::Authenticator.new{ |context|
  context.authentication_methods.push 'publickey'
  HrrRbSsh::Authentication::PARTIAL_SUCCESS
}
auth_publickey = HrrRbSsh::Authentication::Authenticator.new{ |context|
  if some_verification(context)
    case context.username
    when 'user1'
      context.authentiation_methods.push 'keyboard-interactive'
      HrrRbSsh::Authentication::PARTIAL_SUCCESS
    else
      false
    end
  else
    false
  end
}
auth_keyboard_interactive = HrrRbSsh::Authentication::Authenticator.new{ |context|
  if some_verification(context)
    true # or HrrRbSsh::Authentication::PARTIAL_SUCCESS; both will accept the user because remaining authentication method is only 'keyboard-interactive' in this case
  else
    false
  end
}
options['authentication_preferred_authentication_methods'] = auth_preferred_authentication_methods
options['authentication_none_authenticator'] = auth_none
options['authentication_publickey_authenticator'] = auth_publickey
options['authentication_keyboard_interactive_authenticator'] = auth_keyboard_interactive

By default, any channel requests belonging to session channel are implicitly ignored. To handle the requests, defining request handlers are required.

There are pre-implemented request handlers available for reference as below.

options['connection_channel_request_pty_req']       = HrrRbSsh::Connection::RequestHandler::ReferencePtyReqRequestHandler.new
options['connection_channel_request_env']           = HrrRbSsh::Connection::RequestHandler::ReferenceEnvRequestHandler.new
options['connection_channel_request_shell']         = HrrRbSsh::Connection::RequestHandler::ReferenceShellRequestHandler.new
options['connection_channel_request_exec']          = HrrRbSsh::Connection::RequestHandler::ReferenceExecRequestHandler.new
options['connection_channel_request_window_change'] = HrrRbSsh::Connection::RequestHandler::ReferenceWindowChangeRequestHandler.new

It is also possible to define customized request handlers. For instance, echo server can be implemented very easily as below. In this case, echo server works instead of shell and PTY-req and env requests are undefined.

conn_echo = HrrRbSsh::Connection::RequestHandler.new { |context|
  context.chain_proc { |chain|
    begin
      loop do
        buf = context.io[0].readpartial(10240)
        break if buf.include?(0x04.chr) # break if ^D
        context.io[1].write buf
      end
      exitstatus = 0
    rescue => e
      logger.error([e.backtrace[0], ": ", e.message, " (", e.class.to_s, ")\n\t", e.backtrace[1..-1].join("\n\t")].join)
      exitstatus = 1
    end
    exitstatus
  }
}
options['connection_channel_request_shell'] = conn_echo

In HrrRbSsh::Connection::RequestHandler.new block, context variable basically provides the followings.

• #io => [in, out, err] : in is readable and read data is sent by remote. out and err are writable. out is for standard output and written data is sent as channel data. err is for standard error and written data is sent as channel extended data.
• #chain_proc => {|chain| ... } : When a session channel is opened, a background thread is started and is waitng for a chained block registered. This #chain_proc is used to define how to handle subsequent communications between local and remote. The chain variable provides #call_next method. In #proc_chain block, it is possible to call subsequent block that is defined in another request handler. For instance, shell request must called after pty-req request. The chain in pty-req request handler’s #chain_proc calls #next_proc and then subsequent shell request handler’s #chain_proc will be called.
• #close_session : In most cases, input and output between a client and the server is handled in #chain_proc and closing the #chain_proc block will lead closing the underlying session channel. This means that to close the underlying session channel it is required to write at least one #chain_proc block. If it is not required to use #chain_proc block or is required to close the underlying session channel from outside of #chain_proc block, #close_session can be used. The #close_session will close the background thread that calls #chain_proc blocks.
• #variables => Hash : A hash instance that is passed from authenticator and is shared in subsequent session channel request handlers
• #vars : The same object that #variables returns

And request handler’s context variable also provides additional methods based on request type. See lib/hrr_rb_ssh/connection/channel/channel_type/session/request_type/<request type>/context.rb.

Preferred encryption, server-host-key, KEX and compression algorithms can be selected and defined.

options['transport_preferred_encryption_algorithms']      = %w(aes256-ctr aes128-cbc)
options['transport_preferred_server_host_key_algorithms'] = %w(ecdsa-sha2-nistp256 ssh-rsa)
options['transport_preferred_kex_algorithms']             = %w(ecdh-sha2-nistp256 diffie-hellman-group14-sha1)
options['transport_preferred_mac_algorithms']             = %w(hmac-sha2-256 hmac-sha1)
options['transport_preferred_compression_algorithms']     = %w(none)

Supported algorithms can be got with each algorithm class’s #list_supported method, and default preferred algorithms can be got with each algorithm class’s #list_preferred method.

Outputs of #list_preferred method are ordered as preferred; i.e. the name listed at head is used as most preferred, and the name listed at tail is used as non-preferred.

p HrrRbSsh::Transport::EncryptionAlgorithm.list_supported
# => ["none", "3des-cbc", "blowfish-cbc", "aes128-cbc", "aes192-cbc", "aes256-cbc", "arcfour", "cast128-cbc", "aes128-ctr", "aes192-ctr", "aes256-ctr"]
p HrrRbSsh::Transport::EncryptionAlgorithm.list_preferred
# => ["aes128-ctr", "aes192-ctr", "aes256-ctr", "aes128-cbc", "3des-cbc", "blowfish-cbc", "cast128-cbc", "aes192-cbc", "aes256-cbc", "arcfour"]

p HrrRbSsh::Transport::ServerHostKeyAlgorithm.list_supported
# => ["ssh-dss", "ssh-rsa", "ecdsa-sha2-nistp256", "ecdsa-sha2-nistp384", "ecdsa-sha2-nistp521"]
p HrrRbSsh::Transport::ServerHostKeyAlgorithm.list_preferred
# => ["ecdsa-sha2-nistp521", "ecdsa-sha2-nistp384", "ecdsa-sha2-nistp256", "ssh-rsa", "ssh-dss"]

p HrrRbSsh::Transport::KexAlgorithms.new.list_supported
# => ["diffie-hellman-group1-sha1", "diffie-hellman-group14-sha1", "diffie-hellman-group-exchange-sha1", "diffie-hellman-group-exchange-sha256", "diffie-hellman-group14-sha256", "diffie-hellman-group15-sha512", "diffie-hellman-group16-sha512", "diffie-hellman-group17-sha512", "diffie-hellman-group18-sha512", "ecdh-sha2-nistp256", "ecdh-sha2-nistp384", "ecdh-sha2-nistp521"]
p HrrRbSsh::Transport::KexAlgorithms.new.list_preferred
# => ["ecdh-sha2-nistp521", "ecdh-sha2-nistp384", "ecdh-sha2-nistp256", "diffie-hellman-group18-sha512", "diffie-hellman-group17-sha512", "diffie-hellman-group16-sha512", "diffie-hellman-group15-sha512", "diffie-hellman-group14-sha256", "diffie-hellman-group-exchange-sha256", "diffie-hellman-group-exchange-sha1", "diffie-hellman-group14-sha1", "diffie-hellman-group1-sha1"]

p HrrRbSsh::Transport::MacAlgorithm.list_supported
# => ["none", "hmac-sha1", "hmac-sha1-96", "hmac-md5", "hmac-md5-96", "hmac-sha2-256", "hmac-sha2-512"]
p HrrRbSsh::Transport::MacAlgorithm.list_preferred
# => ["hmac-sha2-512", "hmac-sha2-256", "hmac-sha1", "hmac-md5", "hmac-sha1-96", "hmac-md5-96"]

p HrrRbSsh::Transport::CompressionAlgorithm.list_supported
# => ["none", "zlib"]
p HrrRbSsh::Transport::CompressionAlgorithm.list_preferred
# => ["none", "zlib"]

By default, hrr_rb_ssh sends SSH-2.0-HrrRbSsh-#{VERSION} string at initial negotiation with remote peer. To address security concerns, it is possible to replace the version string.

# Hiding version
options['local_version'] = "SSH-2.0-HrrRbSsh"

# Simulating OpenSSH
options['local_version'] = "SSH-2.0-OpenSSH_x.x"

# Simulating OpenSSH and hiding version
options['local_version'] = "SSH-2.0-OpenSSH"

Please note that the beginning of the string must be SSH-2.0-. Otherwise SSH 2.0 remote peer cannot continue negotiation with the local peer.

The client mode can be started with HrrRbSsh::Client.start. The method takes target and options arguments. The target that the SSH client connects to can be one of:

• (IO) An io that is open for input and output
• (Array) An array of the target host address or host name and its service port number
• (String) The target host address or host name; in this case the target service port number will be 22

And the options contains various parameters for the SSH connection. At least username key must be set in the options. Also at least one of password, publickey, or keyboard-interactive needs to be set for authentication instead of authenticators that are used in server mode. Also as similar to server mode, it is possible to specify preferred transport algorithms and preferred authentication methods with the same keywords.

target = ['remotehost', 22]
options = {
  username: 'user1',
  password: 'password1',
  publickey: ['ssh-rsa', "/home/user1/.ssh/id_rsa")],
  authentication_preferred_authentication_methods = ['publickey', 'password'],
}
HrrRbSsh::Client.start(target, options) do |conn|
  # Do something here
  # For instance: conn.exec "command"
end

There are some methods supported in client mode. The methods works as a receiver of conn block variable.

The exec and exec! methods execute command on a remote host. Both takes a command argument that is executed in the remote host. And they can take optional pty and env arguments. When pty: true is set, then the command will be executed on a pseudo-TTY. When env: {'key' => 'value'} is set, then the environmental variables are set before the command is executed.

The exec! method returns [stdout, stderr] outputs. Once the command is executed and the outputs are completed, then the method returns the value.

conn.exec! "command" # => [stdout, stderr]

On the other hand, exec method takes block like the below example and returns exit status of the command. When the command is executed and the outputs and reading them are finished, then io_out and io_err return EOF.

conn.exec "command" do |io_in, io_out, io_err|
  # Do something here
end

The shell method provides a shell access on a remote host. As similar to exec method, it takes block and its block variable is also io_in, io_out, io_err. shell is always on pseudo-TTY, so it doesn’t take pty optional argument. It takes env optional argument. Exiting shell will leads io_out and io_err EOF.

conn.shell do |io_in, io_out, io_err|
  # Do something here
end

The subsystem method is to start a subsystem on a remote host. The method takes a subsystem name argument and a block. Its block variable is also io_in, io_out, io_err. subsystem doesn’t take pty nor env optional argument.

conn.subsystem("echo") do |io_in, io_out, io_err|
  # Do something here
end

The demo/server.rb shows a good example on how to use the hrr_rb_ssh library in SSH server mode. And the demo/client.rb shows an example on how to use the hrr_rb_ssh library in SSH client mode.

The following features are currently supported.

• Session channel
  • Shell (PTY-req, env, shell, window-change) request
  • Exec request
  • Subsystem request
• Local port forwarding (direct-tcpip channel)
• Remote port forwarding (tcpip-forward global request and forwarded-tcpip channel)

• None authentication
• Password authentication
• Public key authentication
  • ssh-dss
  • ssh-rsa
  • ecdsa-sha2-nistp256
  • ecdsa-sha2-nistp384
  • ecdsa-sha2-nistp521
• Keyboard interactive (generic interactive / challenge response) authentication

• Encryption algorithm
  • none
  • 3des-cbc
  • blowfish-cbc
  • aes128-cbc
  • aes192-cbc
  • aes256-cbc
  • arcfour
  • cast128-cbc
  • aes128-ctr
  • aes192-ctr
  • aes256-ctr
• Server host key algorithm
  • ssh-dss
  • ssh-rsa
  • ecdsa-sha2-nistp256
  • ecdsa-sha2-nistp384
  • ecdsa-sha2-nistp521
• Kex algorithm
  • diffie-hellman-group1-sha1
  • diffie-hellman-group14-sha1
  • diffie-hellman-group-exchange-sha1
  • diffie-hellman-group-exchange-sha256
  • diffie-hellman-group14-sha256
  • diffie-hellman-group15-sha512
  • diffie-hellman-group16-sha512
  • diffie-hellman-group17-sha512
  • diffie-hellman-group18-sha512
  • ecdh-sha2-nistp256
  • ecdh-sha2-nistp384
  • ecdh-sha2-nistp521
• Mac algorithm
  • none
  • hmac-sha1
  • hmac-sha1-96
  • hmac-md5
  • hmac-md5-96
  • hmac-sha2-256
  • hmac-sha2-512
• Compression algorithm
  • none
  • zlib

Bug reports and pull requests are welcome on GitHub at https://github.com/hirura/hrr_rb_ssh. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the Contributor Covenant code of conduct.

Everyone interacting in the HrrRbSsh project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the code of conduct.

The gem is available as open source under the terms of the Apache License 2.0.

A GTA III chaos mod with Twitch voting support

To download the mod, select the latest release version to the right and follow the instructions.

This mod does random things to your game after a set interval. (30 seconds by default)

There are way over 400 different effects that can happen, and the list is only growing with each update! Anything from giving the player health, to teleporting them, changing the physics, removing car wheels, making the whole world spin and much more.

A full documented list of effects can be found here.

The mod is highly tweakable, allowing you to have the exact experience you want. Just press F7 at any time, and with the numpad, you will be able to configure any of these options to your heart’s content.

Main Options:

• Toggle the mod on and off
• Choose whether the mod automatically enables when the game starts

Recommended Features:

• Autosaving, which makes the save menu appear after every passed mission

UI Options:

• Change the scale and color pattern of the timer bar
• Change the position, scale, color and style of the effects list on-screen

Behavior Options:

• Change the amount of time between each new effect
• Twitch voting
• Trigger an effect when someone subscribes on Twitch
• Synced effects, using a global timer to make multiple instances of the mod on different PCs have the same effects happen simultaneously
• Bind a key to triggering an effect

Effect Options:

• Preset filters to disable unstable, controversial or DMCA effects
• Manual tweaks to effects, letting you change the length of and disable any effect

Audio Options:

• Change the volume of effects that have sound

Difficulty Options:

• Change the difficulty to change the available effects and the frequency of bad effects

Twitch Voting Options:

• Choose whether the mod reconnects to Twitch automatically
• Change the color scheme of the voting display
• Choose between proportional and majority voting (Proportional: Votes are a percentage chance, Majority: The effect with the most votes always wins)
• Change the command for voting (1 2 3 4 or c1 c2 c3 c4)
• Change the amount of effects available to be voted on (any amount between 2 and 9)
• Make the voting command alternate between 1 2 3 4 and 5 6 7 8 to prevent votes bleeding over, and to allow more than one identical vote per 30 seconds on Twitch
• Change the method in which the voting display is drawn (Separate window, on-screen or in an .html file)
• Mark Unpicked Effects (Off: The same effect will not be available again until every other effect has won the vote at least once, On: The same effect will not be available again until every other effect has appeared in the voting window)

A GTA III chaos mod with Twitch voting support

To download the mod, select the latest release version to the right and follow the instructions.

This mod does random things to your game after a set interval. (30 seconds by default)

There are way over 400 different effects that can happen, and the list is only growing with each update! Anything from giving the player health, to teleporting them, changing the physics, removing car wheels, making the whole world spin and much more.

A full documented list of effects can be found here.

The mod is highly tweakable, allowing you to have the exact experience you want. Just press F7 at any time, and with the numpad, you will be able to configure any of these options to your heart’s content.

Main Options:

• Toggle the mod on and off
• Choose whether the mod automatically enables when the game starts

Recommended Features:

• Autosaving, which makes the save menu appear after every passed mission

UI Options:

• Change the scale and color pattern of the timer bar
• Change the position, scale, color and style of the effects list on-screen

Behavior Options:

• Change the amount of time between each new effect
• Twitch voting
• Trigger an effect when someone subscribes on Twitch
• Synced effects, using a global timer to make multiple instances of the mod on different PCs have the same effects happen simultaneously
• Bind a key to triggering an effect

Effect Options:

• Preset filters to disable unstable, controversial or DMCA effects
• Manual tweaks to effects, letting you change the length of and disable any effect

Audio Options:

• Change the volume of effects that have sound

Difficulty Options:

• Change the difficulty to change the available effects and the frequency of bad effects

Twitch Voting Options:

• Choose whether the mod reconnects to Twitch automatically
• Change the color scheme of the voting display
• Choose between proportional and majority voting (Proportional: Votes are a percentage chance, Majority: The effect with the most votes always wins)
• Change the command for voting (1 2 3 4 or c1 c2 c3 c4)
• Change the amount of effects available to be voted on (any amount between 2 and 9)
• Make the voting command alternate between 1 2 3 4 and 5 6 7 8 to prevent votes bleeding over, and to allow more than one identical vote per 30 seconds on Twitch
• Change the method in which the voting display is drawn (Separate window, on-screen or in an .html file)
• Mark Unpicked Effects (Off: The same effect will not be available again until every other effect has won the vote at least once, On: The same effect will not be available again until every other effect has appeared in the voting window)

Cargo subcommand to provide various options useful for testing and continuous integration.

• Usage
  • –each-feature
  • –feature-powerset
  • Options for adjusting the behavior of –each-feature and –feature-powerset
    • –optional-deps
    • –exclude-features, –skip
  • –rust-version
  • –version-range
  • Improvement of the behavior of existing cargo flags
• Installation
• Related Projects
• License

$ cargo hack --help
cargo-hack
Cargo subcommand to provide various options useful for testing and continuous integration.

USAGE:
    cargo hack [OPTIONS] [SUBCOMMAND]

Use -h for short descriptions and --help for more details.

OPTIONS:
    -p, --package <SPEC>...
            Package(s) to check.

        --all
            Alias for --workspace.

        --workspace
            Perform command for all packages in the workspace.

        --exclude <SPEC>...
            Exclude packages from the check.

        --manifest-path <PATH>
            Path to Cargo.toml.

        --locked
            Require Cargo.lock is up to date.

    -F, --features <FEATURES>...
            Space or comma separated list of features to activate.

        --each-feature
            Perform for each feature of the package.

            This also includes runs with just --no-default-features flag, and default features.

            When this flag is not used together with --exclude-features (--skip) and
            --include-features and there are multiple features, this also includes runs with just
            --all-features flag.

        --feature-powerset
            Perform for the feature powerset of the package.

            This also includes runs with just --no-default-features flag, and default features.

            When this flag is used together with --depth or namespaced features (-Z
            namespaced-features) and not used together with --exclude-features (--skip) and
            --include-features and there are multiple features, this also includes runs with just
            --all-features flag.

        --optional-deps [DEPS]...
            Use optional dependencies as features.

            If DEPS are not specified, all optional dependencies are considered as features.

            This flag can only be used together with either --each-feature flag or
            --feature-powerset flag.

        --skip <FEATURES>...
            Alias for --exclude-features.

        --exclude-features <FEATURES>...
            Space or comma separated list of features to exclude.

            To exclude run of default feature, using value `--exclude-features default`.

            To exclude run of just --no-default-features flag, using --exclude-no-default-features
            flag.

            To exclude run of just --all-features flag, using --exclude-all-features flag.

            This flag can only be used together with either --each-feature flag or
            --feature-powerset flag.

        --exclude-no-default-features
            Exclude run of just --no-default-features flag.

            This flag can only be used together with either --each-feature flag or
            --feature-powerset flag.

        --exclude-all-features
            Exclude run of just --all-features flag.

            This flag can only be used together with either --each-feature flag or
            --feature-powerset flag.

        --depth <NUM>
            Specify a max number of simultaneous feature flags of --feature-powerset.

            If NUM is set to 1, --feature-powerset is equivalent to --each-feature.

            This flag can only be used together with --feature-powerset flag.

        --group-features <FEATURES>...
            Space or comma separated list of features to group.

            This treats the specified features as if it were a single feature.

            To specify multiple groups, use this option multiple times: `--group-features a,b
            --group-features c,d`

            This flag can only be used together with --feature-powerset flag.

        --target <TRIPLE>
            Build for specified target triple.

            Comma-separated lists of targets are not supported, but you can specify the whole
            --target option multiple times to do multiple targets.

            This is actually not a cargo-hack option, it is interpreted by Cargo itself.

        --mutually-exclusive-features <FEATURES>...
            Space or comma separated list of features to not use together.

            To specify multiple groups, use this option multiple times:
            `--mutually-exclusive-features a,b --mutually-exclusive-features c,d`

            This flag can only be used together with --feature-powerset flag.

        --at-least-one-of <FEATURES>...
            Space or comma separated list of features. Skips sets of features that don't enable any
            of the features listed.

            To specify multiple groups, use this option multiple times: `--at-least-one-of a,b
            --at-least-one-of c,d`

            This flag can only be used together with --feature-powerset flag.

        --include-features <FEATURES>...
            Include only the specified features in the feature combinations instead of package
            features.

            This flag can only be used together with either --each-feature flag or
            --feature-powerset flag.

        --no-dev-deps
            Perform without dev-dependencies.

            Note that this flag removes dev-dependencies from real `Cargo.toml` while cargo-hack is
            running and restores it when finished.

        --remove-dev-deps
            Equivalent to --no-dev-deps flag except for does not restore the original `Cargo.toml`
            after performed.

        --no-private
            Perform without `publish = false` crates.

        --ignore-private
            Skip to perform on `publish = false` packages.

        --ignore-unknown-features
            Skip passing --features flag to `cargo` if that feature does not exist in the package.

            This flag can be used with --features, --include-features, or --group-features.

        --rust-version
            Perform commands on `package.rust-version`.

            This cannot be used with --version-range.

        --version-range [START]..[=END]
            Perform commands on a specified (inclusive) range of Rust versions.

            If the upper bound of the range is omitted, the latest stable compiler is used as the
            upper bound.

            If the lower bound of the range is omitted, the value of the `rust-version` field in
            `Cargo.toml` is used as the lower bound.

            Note that ranges are always inclusive ranges.

        --version-step <NUM>
            Specify the version interval of --version-range (default to `1`).

            This flag can only be used together with --version-range flag.

        --clean-per-run
            Remove artifacts for that package before running the command.

            If used this flag with --workspace, --each-feature, or --feature-powerset, artifacts
            will be removed before each run.

            Note that dependencies artifacts will be preserved.

        --clean-per-version
            Remove artifacts per Rust version.

            Note that dependencies artifacts will also be removed.

            This flag can only be used together with --version-range flag.

        --keep-going
            Keep going on failure.

        --partition <M/N>
            Partition runs and execute only its subset according to M/N.

        --log-group <KIND>
            Log grouping: none, github-actions.

            If this option is not used, the environment will be automatically detected.

        --print-command-list
            Print commands without run (Unstable).

        --no-manifest-path
            Do not pass --manifest-path option to cargo (Unstable).

    -v, --verbose
            Use verbose output.

        --color <WHEN>
            Coloring: auto, always, never.

            This flag will be propagated to cargo.

    -h, --help
            Prints help information.

    -V, --version
            Prints version information.

Some common cargo commands are (see all commands with --list):
    build       Compile the current package
    check       Analyze the current package and report errors, but don't build object files
    run         Run a binary or example of the local package
    test        Run the tests

cargo-hack is basically wrapper of cargo that propagates subcommand and most of the passed flags to cargo, but provides additional flags and changes the behavior of some existing flags.

Perform for each feature which includes default features and --no-default-features of the package.

This is useful to check that each feature is working properly. (When used for this purpose, it is recommended to use with --no-dev-deps to avoid cargo#4866.)

cargo hack check --each-feature --no-dev-deps

See also Options for adjusting the behavior of –each-feature and –feature-powerset section.

Perform for the feature powerset which includes --no-default-features and default features of the package.

This is useful to check that every combination of features is working properly. (When used for this purpose, it is recommended to use with --no-dev-deps to avoid cargo#4866.)

cargo hack check --feature-powerset --no-dev-deps

cargo-hack deduplicate any fully equivalent feature combinations based on how the cargo features work. Therefore, it may be more efficient than checking all feature combinations in other ways.

See also Options for adjusting the behavior of –each-feature and –feature-powerset section.

The following flags can be used with --each-feature and --feature-powerset.

Use optional dependencies as features.

This flag treats all option dependencies as features by default. To treat only specific dependencies as features, pass a space or comma separated list.

cargo hack check --feature-powerset --optional-deps deps1,deps2

Space or comma separated list of features to exclude.

cargo hack check --feature-powerset --exclude-features feature1,feature2
cargo hack check --feature-powerset --skip feature1,feature2

Specify a max number of simultaneous feature flags of --feature-powerset.

If the number is set to 1, --feature-powerset is equivalent to --each-feature.

Space or comma separated list of features to group.

This treats the specified features as if it were a single feature.

To specify multiple groups, use this option multiple times: --group-features a,b --group-features c,d

Perform commands on the Rust version of package.rust-version field in Cargo.toml

Perform commands on a specified (inclusive) range of Rust versions.

$ cargo hack check --version-range 1.46..=1.47
info: running `rustup run 1.46 cargo check` on cargo-hack (1/2)
...
info: running `rustup run 1.47 cargo check` on cargo-hack (2/2)
...

(We use rustup run <toolchain> cargo instead of cargo +<toolchain> to work around a rustup bug.)

This might be useful for catching issues like termcolor#35, regex#685, rust-clippy#6324.

If the upper bound of the range is omitted, the latest stable compiler is used as the upper bound.

If the lower bound of the range is omitted, the value of the rust-version field in Cargo.toml is used as the lower bound.

You can specify the version interval by using --version-step.

Perform without dev-dependencies.

This is a workaround for an issue that dev-dependencies leaking into normal build (cargo#4866).

Also, this can be used as a workaround for an issue that cargo does not allow publishing a package with cyclic dev-dependencies. (cargo#4242)

cargo hack publish --no-dev-deps --dry-run --allow-dirty

Equivalent to --no-dev-deps except for does not restore the original Cargo.toml after execution.

This is useful to know what Cargo.toml that cargo-hack is actually using with --no-dev-deps.

This flag also works without subcommands.

Skip to perform on publish = false crates.

Perform without publish = false crates. This is similar to --ignore-private, but is more powerful because this also prevents private crates from affecting lockfile and metadata.

Skip passing --features to cargo if that feature does not exist.

Remove artifacts for that package before running the command.

This also works as a workaround for rust-clippy#4612.

cargo-hack changes the behavior of the following existing flags.

Unlike cargo (cargo#3620, cargo#4106, cargo#4463, cargo#4753, cargo#5015, cargo#5364, cargo#6195), it can also be applied to sub-crates.

Perform command for all packages in the workspace.

Unlike cargo, it does not compile all members at once.

For example, running cargo hack check --all in a workspace with members foo and bar behaves almost the same as the following script:

# If you use cargo-hack, you don't need to maintain this list manually.
members=("foo" "bar")

for member in "${members[@]}"; do
    cargo check --manifest-path "${member}/Cargo.toml"
done

Workspace members will be performed according to the order of the ‘packages’ fields of cargo metadata.

cargo +stable install cargo-hack --locked

Currently, installing cargo-hack requires rustc 1.70+.

cargo-hack is usually runnable with Cargo versions older than the Rust version required for installation (e.g., cargo +1.31 hack check). Currently, to run cargo-hack requires Cargo 1.26+.

You can download prebuilt binaries from the Release page. Prebuilt binaries are available for macOS, Linux (gnu and musl), Windows (static executable), FreeBSD, and illumos.

# Get host target
host=$(rustc -vV | grep '^host:' | cut -d' ' -f2)
# Download binary and install to $HOME/.cargo/bin
curl --proto '=https' --tlsv1.2 -fsSL "https://github.com/taiki-e/cargo-hack/releases/latest/download/cargo-hack-$host.tar.gz" \
  | tar xzf - -C "$HOME/.cargo/bin"

You can use taiki-e/install-action to install prebuilt binaries on Linux, macOS, and Windows. This makes the installation faster and may avoid the impact of problems caused by upstream changes.

- uses: taiki-e/install-action@cargo-hack

You can install cargo-hack from homebrew-core (x86_64/AArch64 macOS, x86_64 Linux):

brew install cargo-hack

Alternatively, you can also install from the Homebrew tap maintained by us (x86_64/AArch64 macOS, x86_64/AArch64 Linux):

brew install taiki-e/tap/cargo-hack

You can install cargo-hack from the Scoop bucket maintained by us:

scoop bucket add taiki-e https://github.com/taiki-e/scoop-bucket
scoop install cargo-hack

You can install cargo-hack using cargo-binstall:

cargo binstall cargo-hack

You can install cargo-hack from the extra repository:

pacman -S cargo-hack

You can install cargo-hack from the official ports:

pkg install cargo-hack

• cargo-llvm-cov: Cargo subcommand to easily use LLVM source-based code coverage.
• cargo-minimal-versions: Cargo subcommand for proper use of -Z minimal-versions.
• cargo-config2: Library to load and resolve Cargo configuration.
• cargo-no-dev-deps: Cargo subcommand for running cargo without dev-dependencies. This is an extraction of the --no-dev-deps flag of cargo-hack to be used as a stand-alone cargo subcommand.

Licensed under either of Apache License, Version 2.0 or MIT license at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

[TOC]

Some people say that computer graphics generally includes geometry, rendering and simulation. Others say that computer graphics mainly includes modeling, rendering, animation and human-computer interaction. In this book list, I want to summarize the books that can be read from two aspects: computational geometry and computer graphics. Computer graphics mainly summarizes the mathematical basis of graphics, rendering, animation, simulation, game engine design and development, graphics api, etc. Computational geometry mainly summarizes the basic geometry such as points, lines and planes and their relationships.

It is under continuous update. This update is on August 10, 2023. It is not finished yet to be continued.

welcome star !

Personal Website：https://www.stubbornhuang.com/1256/

中文说明

• Fundamentals of Computer Graphics
• Physically Based Rendering From Theory To Implementation
• Real-Time Rendering
• GPU Gems
• ShaderX
• GPU Pro
• GPU Zen
• GPU Pro 360
• Foundations of Game Engine Development
• 3D Math Primer for Graphics and Game Development
• Essential Mathematics for Games and Interactive Applications
• Jim Blinn’s Corner
• Game Engine Gems
• Game Engine Architecture
• Graphics Gems
• Ray Tracing in One Week
• Game Programming Gems
• The HDRI Handbook
• High Dynamic Range Imaging
• Interactive Computer Graphics
• Realistic Image Synthesis Using Photon Mapping
• Ray Tracing Gems
• Efficient Illumination Algorithms for Global Illumination In Interactive and Real-Time Rendering
• Mathematics for 3D Game Programming and Computer Graphics
• Real-Time Shadows
• Advanced global illumination
• Computer Graphics Principles and Practice
• Computer Graphics Through OpenGL – From Theory to Experiments
• Game Physics Engine Development- How to Build a Robust Commercial-Grade Physics Engine for your Game
• Graphics Shaders – Theory and Practice
• Insights
• The Magic of Computer Graphics – Landmarks in Rendering
• OpenGL Programming Guide
• OpenGL SuperBible
• OpenGL 4.0 Shading Language Cookbook
• OpenGL Shading Language
• Fluid Engine Development
• Fluid Simulation for Computer Graphics
• The Nature of Code – Simulating Natural Systems with Processing
• Game Physics Pearls
• Game Physics
• Game Physics Cookbook
• Physics for Game Developers
• Physics for Game Programmers
• Physics Modeling for Game Programmers
• Physics-Based Animation
• Foundations of Physically Based Modeling and Animation
• Production Volume Rendering – Design and Implementation
• Collision Detection in Interactive 3D Environments
• Real-Time Collision Detection
• Introduction to 3D Game Programming with DirectX
• Practical Rendering and Computation with Direct3D 11
• Real-Time 3D Rendering with DirectX and HLSL – A Practical Guide to Graphics Programming
• The Art of Fluid Animation
• Ray Tracing from the Ground Up
• Character Animation With Direct3D
• Real-time 3D Character Animation with Visual C++
• Vulkan Programming Guide – The Official Guide to Learning Vulkan
• Learning Vulkan
• Vulkan Cookbook – Work through recipes to unlock the full potential of the next generation graphics API-Vulkan
• GLSL Essentials – Enrich your 3D scenes with the power of GLSL
• Computer Animation – Algorithms and Techniques
• The Ray Tracer Challenge – A Test-Driven Guide to Your First 3D Renderer
• Ray Tracing – A Tool for All
• Cloth Simulation for Computer Graphics
• Real-Time Volume Graphics
• Computer Graphics from Scratch – A Programmer’s Introduction to 3D Rendering
• 3D Game Engine Design – A Practical Approach to Real-Time Computer Graphics
• 3D Game Engine Architecture – Engineering Real-Time Applications with Wild Magic
• Real-Time Cameras – A Guide for Game Designers and Developers
• Game AI Pro – Collected Wisdom of Game AI Professionals
• Game AI Pro 360
• Visualizing Quaternions
• Quaternions for Computer Graphics
• 3D Engine Design for Virtual Globes
• Texturing and Modeling – A Procedural Approach
• Level of Detail for 3D Graphics
• Non-Photorealistic Rendering
• Non-Photorealistic Computer Graphics – Modeling, Rendering, and Animation
• The Algorithms and Principles of Non-photorealistic Graphics – Artistic Rendering and Cartoon Animation
• Digital Character Development – Theory and Practice
• 3D Graphics Rendering Cookbook – A comprehensive guide to exploring rendering algorithms in modern OpenGL and Vulkan
• Tricks of the 3D Game Programming Gurus – Advanced 3D Graphics and Rasterization
• Graphics Programming Methods
• Principles of Digital Image Synthesis
• Digital Image Processing
• Game Development Tools
• Div, Grad, Curl, and All That – An Informal Text on Vector Calculus
• Game Programming Algorithms and Techniques – A Platform-Agnostic Approach
• Game Programming Patterns
• Game Programming Golden Rules
• Augmented Reality – Principles and Practice
• Practical Augmented Reality – A Guide to the Technologies, Applications, and Human Factors for AR and VR-Addison
• VR Developer Gems
• Image Objects – An Archaeology of Computer Graphics
• Advanced High Dynamic Range Imaging
• A Biography of the Pixel
• Computer Graphics Programming in OpenGL with C++
• GPGPU Programming for Games and Science
• Computer Facial Animation
• Handbook of Digital Image Synthesis – Scientific Foundations of Rendering
• Image Content Retargeting – Maintaining Color, Tone, and Spatial Consistency
• Introduction to Computer Graphics – A Practical Learning Approach
• Direct3D Rendering Cookbook
• Practical Algorithms for 3D Computer Graphics
• Computer Graphics – From Pixels to Programmable Graphics Hardware
• The History of Visual Magic in Computers – How Beautiful Images are Made in CAD, 3D, VR and AR
• WebGL Programming Guide – Interactive 3D Graphics Programming with WebGL
• Beginning DirectX 11 Game Programming
• The CUDA Handbook – A Comprehensive Guide to GPU Programming
• OpenGL Development Cookbook
• GPU Computing Gems
• 3D Graphics for Game Programming
• Light & Skin Interactions – Simulations for Computer Graphics Applications
• Video Game Optimization
• Mathematics for Computer Graphics
• An Integrated Introduction to Computer Graphics and Geometric Modeling
• Digital Modeling of Material Appearance
• Color Imaging – Fundamentals and Applications
• Data Structures and Algorithms for Game Developers
• Geometric Data Structures for Computer Graphics
• Advances in GPU Research and Practice
• Learn OpenGL – Learn modern OpenGL graphics programming in a step-by-step fashion
• Simulating Humans – Computer Graphics Animation and Control
• WebGL Gems – Learn How To Create 3D Worlds And Games For Modern Web Browsers
• Computer Graphics, C Version
• Vector Analysis for Computer Graphics
• Calculus for Computer Graphics
• Digital Lighting & Rendering
• Foundations of 3D computer graphics
• Computer Graphics with OpenGL
• Practical Linear Algebra – A Geometry Toolbox
• An Introduction to Ray Tracing
• AI Game Engine Programming
• AI Game Programming Wisdom
• Artificial Intelligence for Games
• Behavioral Mathematics for Game AI
• Cloth Modeling and Animation
• Virtual Clothing – Theory and Practice
• Computer Graphics and Geometric Modelling – Implementation and Algorithms
• Designing the User Experience of Game Development Tools
• Real-Time 3D Graphics with WebGL 2
• Rotation Transforms for Computer Graphics
• Matrix Transforms for Computer Games and Animation
• Mathematical Basics of Motion and Deformation in Computer Graphics
• Geometric and Discrete Path Planning for Interactive Virtual Worlds
• Hands-On C++ Game Animation Programming
• An Introduction to Computational Fluid Dynamics – The Finite Volume Method
• Mastering Graphics Programming with Vulkan
• Practical Shader Development – Vertex and Fragment Shaders for Game Developers
• The Modern Vulkan Cookbook – A practical guide to 3D graphics and advanced real-time rendering techniques in Vulkan

• Polygon Mesh Processing
• Computational Geometry – Algorithms and Applications
• Handbook of Discrete and Computational Geometry
• Geometric tools for computer graphics
• Computational Geometry in C
• Computational Geometry：An Introduction
• Geometric Algebra for Computer Science – An Object-Oriented Approach to Geometry
• Isosurfaces – Geometry, Topology, and Algorithms
• Guide to Computational Geometry Processing Foundations, Algorithms, and Methods
• Discrete and Computational Geometry
• Robust and Error-Free Geometric Computing
• Implicit Curves and Surfaces – Mathematics, Data Structures and Algorithms
• Computational Geometry – An Introduction Through Randomized Algorithms
• Effective Computational Geometry for Curves and Surfaces
• Nonlinear Computational Geometry
• Handbook of Computer Aided Geometric Design
• Computational Geometry on Surfaces – Performing Computational Geometry on the Cylinder, the Sphere, the Torus, and the Cone
• Geometry for Computer Graphics – Formulae, Examples and Proofs
• Introduction to Computing with Geometry
• Curves and Surfaces for Computer Graphics
• Geometry for Programmers

Cover	Title	Url
	Fundamentals of Computer Graphics, Second Edition	https://www.stubbornhuang.com/1343/
	Fundamentals of Computer Graphics, Third Edition	https://www.stubbornhuang.com/1065/
	Fundamentals of Computer Graphics, Fourth Edition	https://www.stubbornhuang.com/1071/
	Fundamentals of Computer Graphics, Fifth Edition	https://www.stubbornhuang.com/1894/

Cover	Title	Url
	Physically Based Rendering From Theory To Implementation(First Edition)	https://www.stubbornhuang.com/1208/
	Physically Based Rendering From Theory To Implementation (Second Edition)	https://www.stubbornhuang.com/1198/
	Physically Based Rendering From Theory To Implementation (Third Edition)	https://www.stubbornhuang.com/862/
	Physically Based Rendering From Theory To Implementation (Fourth Edition)	https://www.stubbornhuang.com/2605/

Cover	Title	Url
	Real-Time Rendering, Second Edition	https://www.stubbornhuang.com/1503/
	Real-Time Rendering, Third Edition	https://www.stubbornhuang.com/896/
	Real-Time Rendering, Fourth Edition	https://www.stubbornhuang.com/897/

Cover	Title	Url
	GPU Gems 1 – Programming Techniques, Tips and Tricks for Real-Time Graphics	https://www.stubbornhuang.com/1230/
	GPU Gems 2 – Programming Techniques for High-Performance Graphics and General-Purpose Computation	https://www.stubbornhuang.com/1231/
	GPU Gems 3	https://www.stubbornhuang.com/1233/

Cover	Title	Url
	ShaderX1 – Vertex and Pixel Shader Tips and Tricks	https://www.stubbornhuang.com/1294/
	ShaderX2 – Introductions and Tutorials with DirectX9.0	https://www.stubbornhuang.com/1298/
	ShaderX3 – Advanced Rendering with DirectX and OpenGL	https://www.stubbornhuang.com/1300/
	ShaderX4 – Advanced Rendering Techniques	https://www.stubbornhuang.com/2877/
	ShaderX5 – Advanced Rendering Techniques	https://www.stubbornhuang.com/1305/
	ShaderX6 – Advanced Rendering Techniques	https://www.stubbornhuang.com/2878/
	ShaderX7 – Advanced Rendering Techniques	https://www.stubbornhuang.com/1312/

Cover	Title	Url
	GPU Pro 1 – Advanced Rendering Techniques	https://www.stubbornhuang.com/1275/
	GPU Pro 2 – Advanced Rendering Techniques	https://www.stubbornhuang.com/1280/
	GPU Pro 3 – Advanced Rendering Techniques	https://www.stubbornhuang.com/1282/
	GPU Pro 4 – Advanced Rendering Techniques	https://www.stubbornhuang.com/1285/
	GPU Pro 5 – Advanced Rendering Techniques	https://www.stubbornhuang.com/1286/
	GPU Pro 6 – Advanced Rendering Techniques	https://www.stubbornhuang.com/1288/
	GPU Pro 7 – Advanced Rendering Techniques	https://www.stubbornhuang.com/1292/

Cover	Title	Url
	GPU Zen 1：Advanced Rendering Techniques	https://www.stubbornhuang.com/899/
	GPU Zen 2：Advanced Rendering Techniques	https://www.stubbornhuang.com/1341/

Cover	Title	Url
	GPU Pro 360 – Guide to 3D Engine Design	https://www.stubbornhuang.com/1320/
	GPU Pro 360 – Guide to Geometry Manipulation	https://www.stubbornhuang.com/1321/
	GPU Pro 360 – Guide to GPGPU	https://www.stubbornhuang.com/1322/
	GPU Pro 360 – Guide to Image Space	https://www.stubbornhuang.com/1323/
	GPU Pro 360 – Guide to Lighting	https://www.stubbornhuang.com/1328/
	GPU Pro 360 – Guide to Mobile Devices	https://www.stubbornhuang.com/1333/
	GPU Pro 360 – Guide to Rendering	https://www.stubbornhuang.com/1337/
	GPU Pro 360 – Guide to Shadows	https://www.stubbornhuang.com/1339/

Cover	Title	Url
	Foundations of Game Engine Development, Volume 1 Mathematics	https://www.stubbornhuang.com/1345/
	Foundations of Game Engine Development, Volume 2 Rendering	https://www.stubbornhuang.com/1347/

Cover	Title	Url
	3D Math Primer for Graphics and Game Development (First Edition)	https://www.stubbornhuang.com/1356/
	3D Math Primer for Graphics and Game Development (Second Edition)	https://www.stubbornhuang.com/1358/

Cover	Title	Url
	Essential Mathematics for Games and Interactive Applications(First Edition)	https://www.stubbornhuang.com/1349/
	Essential Mathematics for Games and Interactive Applications(Second Edition)	https://www.stubbornhuang.com/1353/
	Essential Mathematics for Games and Interactive Applications(Third Edition)	https://www.stubbornhuang.com/1354/

Cover	Title	Url
	Jim Blinn’s Corner – A Trip Down the Graphics Pipeline	https://www.stubbornhuang.com/1316/
	Jim Blinn‘s Corner – Dirty Pixels	https://www.stubbornhuang.com/1317/
	Jim Blinn’s Corner – Notation, Notation, Notation	https://www.stubbornhuang.com/1318/

Cover	Title	Url
	Game Engine Gems 1	https://www.stubbornhuang.com/1234/
	Game Engine Gems 2	https://www.stubbornhuang.com/1238/
	Game Engine Gems 3	https://www.stubbornhuang.com/1240/

Cover	Title	Url
	Game Engine Architecture (First Edition)	https://www.stubbornhuang.com/1187/
	Game Engine Architecture (Second Edition)	https://www.stubbornhuang.com/1189/
	Game Engine Architecture (Third Edition)	https://www.stubbornhuang.com/1197/

Cover	Title	Url
	Graphics Gems I	https://www.stubbornhuang.com/1242/
	Graphics Gems II	https://www.stubbornhuang.com/1244/
	Graphics Gems III	https://www.stubbornhuang.com/1249/
	Graphics Gems IV	https://www.stubbornhuang.com/1254/
	Graphics Gems V	https://www.stubbornhuang.com/1255/

Cover	Title	Url
	Ray Tracing in One Weekend	https://www.stubbornhuang.com/1085/
	Ray Tracing – The Next Week	https://www.stubbornhuang.com/1088/
	Ray Tracing – The Rest of Your Life	https://www.stubbornhuang.com/1091/

Cover	Title	Url
	Game Programming Gems 1	https://www.stubbornhuang.com/1258/
	Game Programming Gems 2	https://www.stubbornhuang.com/1261/
	Game Programming Gems 3	https://www.stubbornhuang.com/1263/
	Game Programming Gems 4	https://www.stubbornhuang.com/1267/
	Game Programming Gems 5	缺失
	Game Programming Gems 6	https://www.stubbornhuang.com/1271/
	Game Programming Gems 7	https://www.stubbornhuang.com/1273/
	Game Programming Gems 8	https://www.stubbornhuang.com/1274/

Cover	Title	Url
	The HDRI Handbook- High Dynamic Range Imaging for Photographers and CG Artists	https://www.stubbornhuang.com/1217/
	The HDRI Handbook 2.0- High Dynamic Range Imaging for Photographers and CG Artists	https://www.stubbornhuang.com/1219/

Cover	Title	Url
	High Dynamic Range Imaging- Acquisition, Display, and Image-Based Lighting ( First Edition )	https://www.stubbornhuang.com/1211/
	High Dynamic Range Imaging- Acquisition, Display, and Image-Based Lighting ( Second Edition )	https://www.stubbornhuang.com/1214/

Cover	Title	Url
	Interactive Computer Graphics – A top-down approach with shader-based OpenGL(Six 6th Edition)	https://www.stubbornhuang.com/1204/
	Interactive Computer Graphics – A top-down approach with WebGL(Seven 7th Edition)	https://www.stubbornhuang.com/1205/

Cover	Title	Url
	Realistic Image Synthesis Using Photon Mapping	https://www.stubbornhuang.com/1200/

Cover	Title	Url
	Ray Tracing Gems – High-Quality and Real-Time Rendering with DXR and Other APIs	https://www.stubbornhuang.com/1185/
	Ray Tracing Gems II – Next Generation Real-Time Rendering with DXR, Vulkan, and OptiX-Apress	https://www.stubbornhuang.com/1551/

Cover	Title	Url
	Efficient Illumination Algorithms for Global Illumination In Interactive and Real-Time Rendering	https://www.stubbornhuang.com/1177/

Cover	Title	Url
	Mathematics for 3D Game Programming and Computer Graphics, Second Edition	https://www.stubbornhuang.com/1174/
	Mathematics for 3D Game Programming and Computer Graphics, Third Edition	https://www.stubbornhuang.com/1175/

Cover	Title	Url
	Real-Time Shadows	https://www.stubbornhuang.com/1074/

Cover	Title	Url
	Advanced global illumination (2nd Edition)	https://www.stubbornhuang.com/1056/

Cover	Title	Url
	Computer Graphics Principles and Practice (3rd edition)	https://www.stubbornhuang.com/1054/

Cover	Title	Url
	Computer Graphics Through OpenGL – From Theory to Experiments (Second Edition)	https://www.stubbornhuang.com/1176/
	Computer Graphics Through OpenGL – From Theory to Experiments (Third Edition)	https://www.stubbornhuang.com/1049/

Cover	Title	Url
	Game Physics Engine Development (First Edition)	https://www.stubbornhuang.com/1377/
	Game Physics Engine Development- How to Build a Robust Commercial-Grade Physics Engine for your Game (Second Edition)	https://www.stubbornhuang.com/1359/

Cover	Title	Url
	Graphics Shaders – Theory and Practice (Second Edition)	https://www.stubbornhuang.com/1361/

Cover	Title	Url
	OpenGL Insights	https://www.stubbornhuang.com/1366/
	WebGL Insights	https://www.stubbornhuang.com/1367/

Cover	Title	Url
	The Magic of Computer Graphics – Landmarks in Rendering	https://www.stubbornhuang.com/1368/

Cover	Title	Url
	OpenGL Programming Guide – The Official Guide to Learning OpenGL, Versions 3.0 and 3.1 (Seventh Edition)	https://www.stubbornhuang.com/1474/
	OpenGL Programming Guide – The Official Guide to Learning OpenGL, Version 4.3 (Eighth Edition)	https://www.stubbornhuang.com/1485/
	OpenGL Programming Guide – The Official Guide to Learning OpenGL, Version 4.5 with SPIR-V (Ninth Edition)	https://www.stubbornhuang.com/1488/

Cover	Title	Url
	OpenGL SuperBible – Comprehensive Tutorial and Reference (Fifth Edition)	https://www.stubbornhuang.com/1492/
	OpenGL SuperBible – Comprehensive Tutorial and Reference (Sixth Edition)	https://www.stubbornhuang.com/1494/
	OpenGL SuperBible – Comprehensive Tutorial and Reference (Seventh Edition)	https://www.stubbornhuang.com/1499/

Cover	Title	Url
	OpenGL 4.0 Shading Language Cookbook (First Edition)	https://www.stubbornhuang.com/1369/
	OpenGL 4.0 Shading Language Cookbook (Second Edition)	https://www.stubbornhuang.com/1370/
	OpenGL 4.0 Shading Language Cookbook (Third Edition)	https://www.stubbornhuang.com/1373/

Cover	Title	Url
	OpenGL Shading Language (Third Edition)	https://www.stubbornhuang.com/1374/

Cover	Title	Url
	Fluid Engine Development	https://www.stubbornhuang.com/1378/

Cover	Title	Url
	Fluid Simulation for Computer Graphics, First Edition	https://www.stubbornhuang.com/1060/
	Fluid Simulation for Computer Graphics, Second Edition	https://www.stubbornhuang.com/1063/

Cover	Title	Url
	The Nature of Code – Simulating Natural Systems with Processing	https://www.stubbornhuang.com/1610/

Cover	Title	Url
	Game Physics Pearls	https://www.stubbornhuang.com/1379/

Cover	Title	Url
	Game Physics (First Edition)	https://www.stubbornhuang.com/1381/
	Game Physics (Second Edition)	https://www.stubbornhuang.com/1382/

Cover	Title	Url
	Game Physics Cookbook	https://www.stubbornhuang.com/1746/

Cover	Title	Url
	Physics for Game Developers(First Edition)	https://www.stubbornhuang.com/1383/
	Physics for Game Developers(Second Edition)	https://www.stubbornhuang.com/1385/

Cover	Title	Url
	Physics for Game Programmers	https://www.stubbornhuang.com/1386/

Cover	Title	Url
	Physics Modeling for Game Programmers	https://www.stubbornhuang.com/1389/

Cover	Title	Url
	Physics-Based Animation	https://www.stubbornhuang.com/1390/

Cover	Title	Url
	Foundations of Physically Based Modeling and Animation	https://www.stubbornhuang.com/1223/

Cover	Title	Url
	Production Volume Rendering – Design and Implementation	https://www.stubbornhuang.com/1391/

Cover	Title	Url
	Collision Detection in Interactive 3D Environments	https://www.stubbornhuang.com/1392/

Cover	Title	Url
	Real-Time Collision Detection	https://www.stubbornhuang.com/1395/

Cover	Title	Url
	Introduction to 3D Game Programming with DirectX 9.0	https://www.stubbornhuang.com/2125/
	Introduction to 3D Game Programming with DirectX 10	https://www.stubbornhuang.com/2116/
	Introduction to 3D Game Programming with DirectX 11	https://www.stubbornhuang.com/1554/
	Introduction to 3D Game Programming with DirectX 12	https://www.stubbornhuang.com/1397/

Cover	Title	Url
	Practical Rendering and Computation with Direct3D 11	https://www.stubbornhuang.com/1665/

Cover	Title	Url
	Real-Time 3D Rendering with DirectX and HLSL – A Practical Guide to Graphics Programming	https://www.stubbornhuang.com/1668/

Cover	Title	Url
	The Art of Fluid Animation	https://www.stubbornhuang.com/1418/

Cover	Title	Url
	Ray Tracing from the Ground Up	https://www.stubbornhuang.com/1420/

Cover	Title	Url
	Character Animation With Direct3D	https://www.stubbornhuang.com/1421/

Cover	Title	Url
	Real-time 3D Character Animation with Visual C++	https://www.stubbornhuang.com/1674/

Cover	Title	Url
	Vulkan Programming Guide – The Official Guide to Learning Vulkan	https://www.stubbornhuang.com/1423/

Cover	Title	Url
	Learning Vulkan	https://www.stubbornhuang.com/1501/

Cover	Title	Url
	Vulkan Cookbook – Work through recipes to unlock the full potential of the next generation graphics API-Vulkan	https://www.stubbornhuang.com/1502/

Cover	Title	Url
	GLSL Essentials – Enrich your 3D scenes with the power of GLSL	https://www.stubbornhuang.com/1466/

Cover	Title	Url
	Computer Animation – Algorithms and Techniques (First Edition)	https://www.stubbornhuang.com/1467/
	Computer Animation – Algorithms and Techniques (Third Edition)	https://www.stubbornhuang.com/1471/

Cover	Title	Url
	The Ray Tracer Challenge – A Test-Driven Guide to Your First 3D Renderer	https://www.stubbornhuang.com/1556/

Cover	Title	Url
	Ray Tracing – A Tool for All	https://www.stubbornhuang.com/1558/

Cover	Title	Url
	Cloth Simulation for Computer Graphics	https://www.stubbornhuang.com/1560/

Cover	Title	Url
	Real-Time Volume Graphics	https://www.stubbornhuang.com/1564/

Cover	Title	Url
	Computer Graphics from Scratch – A Programmer’s Introduction to 3D Rendering	https://www.stubbornhuang.com/1569/

Cover	Title	Url
	3D Game Engine Design – A Practical Approach to Real-Time Computer Graphics	https://www.stubbornhuang.com/1592/

Cover	Title	Url
	3D Game Engine Architecture – Engineering Real-Time Applications with Wild Magic	https://www.stubbornhuang.com/1664/

Cover	Title	Url
	Real-Time Cameras – A Guide for Game Designers and Developers	https://www.stubbornhuang.com/1596/

Cover	Title	Url
	Game AI Pro – Collected Wisdom of Game AI Professionals	https://www.stubbornhuang.com/1599/
	Game AI Pro 2 – Collected Wisdom of Game AI Professionals	https://www.stubbornhuang.com/1600/
	Game AI Pro 3 – Collected Wisdom of Game AI Professionals	https://www.stubbornhuang.com/1601/

Cover	Title	Url
	Game AI Pro 360 – Guide to Architecture	https://www.stubbornhuang.com/1602/
	Game AI Pro 360 – Guide to Character Behavior	https://www.stubbornhuang.com/1604/
	Game AI Pro 360 – Guide to Movement and Pathfinding	https://www.stubbornhuang.com/1605/
	Game AI Pro 360 – Guide to Tactics and Strategy	https://www.stubbornhuang.com/1607/

Cover	Title	Url
	Visualizing Quaternions	https://www.stubbornhuang.com/1609/

Cover	Title	Url
	Quaternions for Computer Graphics , First Edition	https://www.stubbornhuang.com/1612/
	Quaternions for Computer Graphics , Second Edition	https://www.stubbornhuang.com/2206

Cover	Title	Url
	3D Engine Design for Virtual Globes	https://www.stubbornhuang.com/1613/

Cover	Title	Url
	Texturing and Modeling – A Procedural Approach, Third Edition	https://www.stubbornhuang.com/1614/

Cover	Title	Url
	Level of Detail for 3D Graphics	https://www.stubbornhuang.com/1624/

Cover	Title	Url
	Non-Photorealistic Rendering	https://www.stubbornhuang.com/1631/

Cover	Title	Url
	Non-Photorealistic Computer Graphics – Modeling, Rendering, and Animation	https://www.stubbornhuang.com/1634/

Cover	Title	Url
	The Algorithms and Principles of Non-photorealistic Graphics – Artistic Rendering and Cartoon Animation	https://www.stubbornhuang.com/1635/

Cover	Title	Url
	Digital Character Development – Theory and Practice , First Edition	https://www.stubbornhuang.com/1677/
	Digital Character Development – Theory and Practice , Second Edition	https://www.stubbornhuang.com/1678/

Cover	Title	Url
	3D Graphics Rendering Cookbook – A comprehensive guide to exploring rendering algorithms in modern OpenGL and Vulkan	https://www.stubbornhuang.com/1679/

Cover	Title	Url
	Tricks of the 3D Game Programming Gurus – Advanced 3D Graphics and Rasterization	https://www.stubbornhuang.com/1682/

Cover	Title	Url
	Graphics Programming Methods	https://www.stubbornhuang.com/1685/

Cover	Title	Url
	Principles of Digital Image Synthesis , Volume 1	https://www.stubbornhuang.com/1693/
	Principles of Digital Image Synthesis , Volume 2	https://www.stubbornhuang.com/1693/

Cover	Title	Url
	Digital Image Processing , Second Edition	https://www.stubbornhuang.com/1714/
	Digital Image Processing , Third Edition	https://www.stubbornhuang.com/1717/
	Digital Image Processing , Fourth Edition	https://www.stubbornhuang.com/1718/

Cover	Title	Url
	Game Development Tools	https://www.stubbornhuang.com/1696/

Cover	Title	Url
	Div, Grad, Curl, and All That – An Informal Text on Vector Calculus , Third Edition	https://www.stubbornhuang.com/1720/
	Div, Grad, Curl, and All That – An Informal Text on Vector Calculus , Forth Edition	https://www.stubbornhuang.com/1721/

Cover	Title	Url
	Game Programming Algorithms and Techniques – A Platform-Agnostic Approach	https://www.stubbornhuang.com/1729/

Cover	Title	Url
	Game Programming Patterns	https://www.stubbornhuang.com/1730/

Cover	Title	Url
	Game Programming Golden Rules	https://www.stubbornhuang.com/1731/

Cover	Title	Url
	Augmented Reality – Principles and Practice	https://www.stubbornhuang.com/1734/

Cover	Title	Url
	Practical Augmented Reality – A Guide to the Technologies, Applications, and Human Factors for AR and VR-Addison	https://www.stubbornhuang.com/1735/

Cover	Title	Url
	VR Developer Gems	https://www.stubbornhuang.com/1739/

Cover	Title	Url
	Image Objects – An Archaeology of Computer Graphics	https://www.stubbornhuang.com/1740/

Cover	Title	Url
	Advanced High Dynamic Range Imaging, First Edition	https://www.stubbornhuang.com/1744/
	Advanced High Dynamic Range Imaging, Second Edition	https://www.stubbornhuang.com/1745/

Cover	Title	Url
	A Biography of the Pixel	https://www.stubbornhuang.com/1750/

Cover	Title	Url
	Computer Graphics Programming in OpenGL with C++, First Edition	https://www.stubbornhuang.com/1753/
	Computer Graphics Programming in OpenGL with C++, Second Edition	https://www.stubbornhuang.com/1757/

Cover	Title	Url
	GPGPU Programming for Games and Science	https://www.stubbornhuang.com/1760/

Cover	Title	Url
	Computer Facial Animation , Second Edition	https://www.stubbornhuang.com/1762/

Cover	Title	Url
	Handbook of Digital Image Synthesis – Scientific Foundations of Rendering	https://www.stubbornhuang.com/1764/