code
stringlengths 12
2.05k
| label
int64 0
1
| programming_language
stringclasses 9
values | cwe_id
stringlengths 6
14
| cwe_name
stringlengths 5
103
⌀ | description
stringlengths 36
1.23k
⌀ | url
stringlengths 36
48
⌀ | label_name
stringclasses 2
values |
|---|---|---|---|---|---|---|---|
def file_list io # :nodoc:
header = String.new
read_until_dashes io do |line|
header << line
end
Gem::SafeYAML.safe_load header
end | 1 | Ruby | CWE-502 | Deserialization of Untrusted Data | The application deserializes untrusted data without sufficiently verifying that the resulting data will be valid. | https://cwe.mitre.org/data/definitions/502.html | safe |
def valid_back_url?(back_url)
if CGI.unescape(back_url).include?('..')
return false
end
begin
uri = URI.parse(back_url)
rescue URI::InvalidURIError
return false
end
if uri.host.present? && uri.host != request.host
return false
end
if uri.path.match(%r{/(login|account/register)})
return false
end
if relative_url_root.present? && !uri.path.starts_with?(relative_url_root)
return false
end
return true
end | 0 | Ruby | NVD-CWE-Other | Other | NVD is only using a subset of CWE for mapping instead of the entire CWE, and the weakness type is not covered by that subset. | https://nvd.nist.gov/vuln/categories | vulnerable |
def begin(name)
stack(name).push true
end | 1 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | safe |
def create
Log.add_info(request, params.inspect)
return unless request.post?
parent_id = params[:selectedFolderId]
if params[:thetisBoxEdit].blank?
@mail_folder = nil
else
@mail_folder = MailFolder.new
@mail_folder.name = params[:thetisBoxEdit]
@mail_folder.parent_id = parent_id
@mail_folder.user_id = @login_user.id
@mail_folder.xtype = nil
@mail_folder.save!
end
render(:partial => 'ajax_folder_entry', :layout => false)
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
it 'is possible to specify a custom formatter' do
get '/'
expect(last_response.body).to eq('{:custom_formatter=>"rain!"}')
end | 0 | Ruby | CWE-79 | Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting') | The software does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users. | https://cwe.mitre.org/data/definitions/79.html | vulnerable |
def self.get_comment_of(item_id, user_id)
SqlHelper.validate_token([item_id, user_id])
begin
comment = Comment.where("(user_id=#{user_id}) and (item_id=#{item_id}) and (xtype='#{Comment::XTYPE_DIST_ACK}')").first
rescue => evar
Log.add_error(nil, evar)
end
return comment
end | 0 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | vulnerable |
def render_with_explicit_escaped_template
render :template => "test/hello_w*rld"
end | 1 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | safe |
def self.get_next_revision(user_id, source_id)
SqlHelper.validate_token([user_id, source_id])
copied_items = Item.where("user_id=#{user_id.to_i} and source_id=#{source_id.to_i}").order('created_at DESC').to_a
rev = 0
copied_items.each do |item|
rev_ary = item.title.scan(/[#](\d\d\d)$/)
next if rev_ary.nil?
rev = rev_ary.first.to_a.first.to_i
break
end
return ('#' + sprintf('%03d', rev+1))
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def set_resource_utilization(params, reqest, session)
unless allowed_for_local_cluster(session, Permissions::WRITE)
return 403, 'Permission denied'
end
unless params[:resource_id] and params[:name]
return 400, 'resource_id and name are required'
end
res_id = params[:resource_id]
name = params[:name]
value = params[:value] || ''
_, stderr, retval = run_cmd(
session, PCS, 'resource', 'utilization', res_id, "#{name}=#{value}"
)
if retval != 0
return [400, "Unable to set utilization '#{name}=#{value}' for " +
"resource '#{res_id}': #{stderr.join('')}"
]
end
return 200
end | 0 | Ruby | CWE-384 | Session Fixation | Authenticating a user, or otherwise establishing a new user session, without invalidating any existing session identifier gives an attacker the opportunity to steal authenticated sessions. | https://cwe.mitre.org/data/definitions/384.html | vulnerable |
def more?
@cursor_id != 0
end | 1 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | safe |
def self.update_xorder(title, order)
if title.nil?
con = nil
else
con = ['title=?', title]
end
SqlHelper.validate_token([order])
User.update_all("xorder=#{order.to_i}", con)
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def test_edit
get :edit, {:id => Hostgroup.first}, set_session_user
assert_template 'edit'
end | 0 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | vulnerable |
def self.search_by_puppetclass(key, operator, value)
conditions = sanitize_sql_for_conditions(["puppetclasses.name #{operator} ?", value_to_sql(operator, value)])
hosts = Host.my_hosts.all(:conditions => conditions, :joins => :puppetclasses, :select => 'DISTINCT hosts.id').map(&:id)
host_groups = Hostgroup.all(:conditions => conditions, :joins => :puppetclasses, :select => 'DISTINCT hostgroups.id').map(&:id)
opts = ''
opts += "hosts.id IN(#{hosts.join(',')})" unless hosts.blank?
opts += " OR " unless hosts.blank? || host_groups.blank?
opts += "hostgroups.id IN(#{host_groups.join(',')})" unless host_groups.blank?
opts = "hosts.id < 0" if hosts.blank? && host_groups.blank?
return {:conditions => opts, :include => :hostgroup}
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
it 'parses zero-leading exponent numbers correctly' do
expect(Raven::OkJson.decode("[123e090]")).to eq [123000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]
end | 0 | Ruby | CWE-399 | Resource Management Errors | Weaknesses in this category are related to improper management of system resources. | https://cwe.mitre.org/data/definitions/399.html | vulnerable |
def get_cib(params, request, session)
if not allowed_for_local_cluster(session, Permissions::READ)
return 403, 'Permission denied'
end
cib, stderr, retval = run_cmd(session, CIBADMIN, "-Ql")
if retval != 0
if not pacemaker_running?
return [400, '{"pacemaker_not_running":true}']
end
return [500, "Unable to get CIB: " + cib.to_s + stderr.to_s]
else
return [200, cib]
end
end | 0 | Ruby | CWE-384 | Session Fixation | Authenticating a user, or otherwise establishing a new user session, without invalidating any existing session identifier gives an attacker the opportunity to steal authenticated sessions. | https://cwe.mitre.org/data/definitions/384.html | vulnerable |
def test_full_sanitize_allows_turning_off_encoding_special_chars
assert_equal '&', full_sanitize('&')
assert_equal '&', full_sanitize('&', encode_special_chars: false)
end | 0 | Ruby | CWE-79 | Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting') | The software does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users. | https://cwe.mitre.org/data/definitions/79.html | vulnerable |
it "sets slave_ok on the query flags" do
session.stub(socket_for: socket)
socket.should_receive(:execute) do |query|
query.flags.should include :slave_ok
end
session.query(query)
end | 0 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | vulnerable |
def test_create_valid
AuthSourceLdap.any_instance.stubs(:valid?).returns(true)
post :create, {:auth_source_ldap => {:name => AuthSourceLdap.unscoped.first.name}}, set_session_user
assert_redirected_to auth_source_ldaps_url
end | 1 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | safe |
def resource_unclone(params, request, session)
if not allowed_for_local_cluster(session, Permissions::WRITE)
return 403, 'Permission denied'
end
unless params[:resource_id]
return [400, 'resource_id has to be specified.']
end
_, stderr, retval = run_cmd(
session, PCS, 'resource', 'unclone', params[:resource_id]
)
if retval != 0
return [400, 'Unable to unclone ' +
"'#{params[:resource_id]}': #{stderr.join('')}"
]
end
return 200
end | 0 | Ruby | CWE-384 | Session Fixation | Authenticating a user, or otherwise establishing a new user session, without invalidating any existing session identifier gives an attacker the opportunity to steal authenticated sessions. | https://cwe.mitre.org/data/definitions/384.html | vulnerable |
def get_path
Log.add_info(request, params.inspect)
if params[:thetisBoxSelKeeper].nil? or params[:thetisBoxSelKeeper].empty?
@folder_path = '/' + t('paren.unknown')
render(:partial => 'ajax_folder_path', :layout => false)
return
end
@selected_id = params[:thetisBoxSelKeeper].split(':').last
@folder_path = Folder.get_path(@selected_id)
render(:partial => 'ajax_folder_path', :layout => false)
end | 0 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | vulnerable |
def insert(documents)
documents = [documents] unless documents.is_a? Array
insert = Protocol::Insert.new(database.name, name, documents)
database.session.with(consistency: :strong) do |session|
session.execute insert
end
end | 0 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | vulnerable |
def restrict_user_fields?(user)
user.trust_level == TrustLevel[0] && anonymous?
end | 0 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | vulnerable |
def self.delete_statistics_group(group_id)
yaml = Research.get_config_yaml
if yaml.nil? or yaml[:statistics].nil?
return []
end
groups = yaml[:statistics][:groups]
return [] if groups.nil?
ary = groups.split('|')
ary.delete group_id.to_s
ary.compact!
ary.delete('')
yaml[:statistics][:groups] = ary.join('|')
Research.save_config_yaml(yaml)
return ary
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def private_messages_for(user, type)
options = @options
options.reverse_merge!(per_page: per_page_setting)
result = Topic.includes(:allowed_users)
result = result.includes(:tags) if SiteSetting.tagging_enabled
if type == :group
result = result.joins(
"INNER JOIN topic_allowed_groups tag ON tag.topic_id = topics.id AND tag.group_id IN (SELECT id FROM groups WHERE LOWER(name) = '#{PG::Connection.escape_string(@options[:group_name].downcase)}')"
)
unless user.admin?
result = result.joins("INNER JOIN group_users gu ON gu.group_id = tag.group_id AND gu.user_id = #{user.id.to_i}")
end
elsif type == :user
result = result.where("topics.id IN (SELECT topic_id FROM topic_allowed_users WHERE user_id = #{user.id.to_i})")
elsif type == :all
result = result.where("topics.id IN (
SELECT topic_id
FROM topic_allowed_users
WHERE user_id = #{user.id.to_i}
UNION ALL
SELECT topic_id FROM topic_allowed_groups
WHERE group_id IN (
SELECT group_id FROM group_users WHERE user_id = #{user.id.to_i}
)
)")
end
result = result.joins("LEFT OUTER JOIN topic_users AS tu ON (topics.id = tu.topic_id AND tu.user_id = #{user.id.to_i})")
.order("topics.bumped_at DESC")
.private_messages
result = result.limit(options[:per_page]) unless options[:limit] == false
result = result.visible if options[:visible] || @user.nil? || @user.regular?
if options[:page]
offset = options[:page].to_i * options[:per_page]
result = result.offset(offset) if offset > 0
end
result
end | 0 | Ruby | CWE-863 | Incorrect Authorization | The software performs an authorization check when an actor attempts to access a resource or perform an action, but it does not correctly perform the check. This allows attackers to bypass intended access restrictions. | https://cwe.mitre.org/data/definitions/863.html | vulnerable |
it "raises a connection failure exception" do
cluster.sync_server(server).should be_empty
end | 0 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | vulnerable |
def self.update_for(user_id, fiscal_year, num)
SqlHelper.validate_token([user_id, fiscal_year])
if num <= 0
con = []
con << "(user_id=#{user_id.to_i})"
con << "(year=#{fiscal_year.to_i})"
PaidHoliday.destroy_all(con.join(' and '))
return
end
paid_holiday = PaidHoliday.get_for(user_id, fiscal_year)
if paid_holiday.nil?
paid_holiday = PaidHoliday.new
paid_holiday.user_id = user_id
paid_holiday.year = fiscal_year
paid_holiday.num = num
paid_holiday.save!
else
paid_holiday.update_attribute(:num, num)
end
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
it "should should include the IndirectionHooks module in its indirection" do
Puppet::FileServing::Content.indirection.singleton_class.included_modules.should include(Puppet::FileServing::IndirectionHooks)
end | 0 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | vulnerable |
it "drops the collection" do
database.should_receive(:command).with(drop: :users)
collection.drop
end | 0 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | vulnerable |
def perform_accept_invitation
params.require(:id)
params.permit(:email, :username, :name, :password, :timezone, :email_token, user_custom_fields: {})
invite = Invite.find_by(invite_key: params[:id])
if invite.present?
begin
attrs = {
username: params[:username],
name: params[:name],
password: params[:password],
user_custom_fields: params[:user_custom_fields],
ip_address: request.remote_ip,
session: session
}
if invite.is_invite_link?
params.require(:email)
attrs[:email] = params[:email]
else
attrs[:email] = invite.email
attrs[:email_token] = params[:email_token] if params[:email_token].present?
end
user = invite.redeem(**attrs)
rescue ActiveRecord::RecordInvalid, ActiveRecord::RecordNotSaved, Invite::UserExists => e
return render json: failed_json.merge(message: e.message), status: 412
end
if user.blank?
return render json: failed_json.merge(message: I18n.t('invite.not_found_json')), status: 404
end
log_on_user(user) if user.active?
user.update_timezone_if_missing(params[:timezone])
post_process_invite(user)
create_topic_invite_notifications(invite, user)
topic = invite.topics.first
response = {}
if user.present?
if user.active?
if user.guardian.can_see?(topic)
response[:redirect_to] = path(topic.relative_url)
else
response[:redirect_to] = path("/")
end
else
response[:message] = I18n.t('invite.confirm_email')
if user.guardian.can_see?(topic)
cookies[:destination_url] = path(topic.relative_url)
end
end
end
render json: success_json.merge(response)
else
render json: failed_json.merge(message: I18n.t('invite.not_found_json')), status: 404
end
end | 0 | Ruby | CWE-863 | Incorrect Authorization | The software performs an authorization check when an actor attempts to access a resource or perform an action, but it does not correctly perform the check. This allows attackers to bypass intended access restrictions. | https://cwe.mitre.org/data/definitions/863.html | vulnerable |
def change_team_status
Log.add_info(request, params.inspect)
return unless request.post?
SqlHelper.validate_token([params[:status]])
team_id = params[:team_id]
begin
team = Team.find(team_id)
team.update_status(params[:status])
@item = team.item
flash[:notice] = t('msg.update_success')
rescue => evar
Log.add_error(request, evar)
flash[:notice] = evar.to_s
end
render(:partial => 'ajax_team_status', :layout => false)
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def add_label options, f, attr
label_size = options.delete(:label_size) || "col-md-2"
required_mark = check_required(options, f, attr)
label = options[:label] == :none ? '' : options.delete(:label)
label ||= ((clazz = f.object.class).respond_to?(:gettext_translation_for_attribute_name) &&
s_(clazz.gettext_translation_for_attribute_name attr)) if f
label = label.present? ? label_tag(attr, "#{label}#{required_mark}".html_safe, :class => label_size + " control-label") : ''
label
end | 0 | Ruby | CWE-79 | Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting') | The software does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users. | https://cwe.mitre.org/data/definitions/79.html | vulnerable |
def get_terminus(request)
indirection.terminus(select(request))
end | 1 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | safe |
def self.get_tmpl_subfolder(name)
SqlHelper.validate_token([name])
tmpl_folder = Folder.where("folders.name='#{TMPL_ROOT}'").first
unless tmpl_folder.nil?
con = "(parent_id=#{tmpl_folder.id}) and (name='#{name}')"
begin
child = Folder.where(con).first
rescue => evar
Log.add_error(nil, evar)
end
end
return [tmpl_folder, child]
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
it 'should authenticate user and delete token' do
user = Fabricate(:user)
get "/session/current.json"
expect(response.status).to eq(404)
token = SecureRandom.hex
$redis.setex "otp_#{token}", 10.minutes, user.username
get "/session/otp/#{token}"
expect(response.status).to eq(302)
expect(response).to redirect_to("/")
expect($redis.get("otp_#{token}")).to eq(nil)
get "/session/current.json"
expect(response.status).to eq(200)
end | 0 | Ruby | NVD-CWE-noinfo | null | null | null | vulnerable |
def spec.validate; end | 1 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | safe |
def updated_ajax
@user = current_site.users.find(params[:user_id])
render inline: @user.update(params.require(:password).permit!) ? "" : @user.errors.full_messages.join(', ')
end | 0 | Ruby | CWE-613 | Insufficient Session Expiration | According to WASC, "Insufficient Session Expiration is when a web site permits an attacker to reuse old session credentials or session IDs for authorization." | https://cwe.mitre.org/data/definitions/613.html | vulnerable |
def list
Log.add_info(request, params.inspect)
con = []
@group_id = nil
if !params[:thetisBoxSelKeeper].nil?
@group_id = params[:thetisBoxSelKeeper].split(':').last
elsif !params[:group_id].blank?
@group_id = params[:group_id]
end
unless @group_id.nil?
if @group_id == '0'
con << "((groups like '%|0|%') or (groups is null))"
else
con << ApplicationHelper.get_sql_like([:groups], "|#{@group_id}|")
end
end
where = ''
unless con.empty?
where = ' where ' + con.join(' and ')
end
order_by = nil
@sort_col = params[:sort_col]
@sort_type = params[:sort_type]
if @sort_col.blank? or @sort_type.blank?
@sort_col = 'id'
@sort_type = 'ASC'
end
SqlHelper.validate_token([@sort_col, @sort_type])
order_by = ' order by ' + @sort_col + ' ' + @sort_type
sql = 'select distinct Equipment.* from equipment Equipment'
sql << where + order_by
@equipment_pages, @equipment, @total_num = paginate_by_sql(Equipment, sql, 20)
end | 0 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | vulnerable |
it "returns false" do
session.should_not be_safe
end | 0 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | vulnerable |
def executing?(name)
!stack(name).empty?
end | 1 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | safe |
it "connects and yields the secondary node" do
Time.stub(:new).and_return(Time.now + 10)
replica_set.with_secondary do |node|
node.command "admin", ping: 1
@secondaries.map(&:address).should include node.address
end
end | 1 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | safe |
def destroy
Log.add_info(request, params.inspect)
return unless request.post?
@folder = Folder.find(params[:id])
unless Folder.check_user_auth(@folder.id, @login_user, 'w', true)
flash[:notice] = 'ERROR:' + t('folder.need_auth_to_modify')
render(:partial => 'common/flash_notice', :layout => false)
return
end
if @folder.count_items(true) > 0
flash[:notice] = 'ERROR:' + t('folder.cannot_delete_with_items')
render(:partial => 'common/flash_notice', :layout => false)
return
end
@folder.force_destroy
@folder = nil
render(:text => '')
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def show_summary
Log.add_info(request, params.inspect)
mail_account_id = params[:id]
SqlHelper.validate_token([mail_account_id])
begin
@mail_account = MailAccount.find(mail_account_id)
rescue => evar
Log.add_error(request, evar)
redirect_to(:controller => 'login', :action => 'logout')
return
end
@folder_tree = MailFolder.get_tree_for(@login_user, [mail_account_id])
# logger.fatal('@@@ ' + sorted_mail_folders.flatten.collect{|rec| rec.name}.inspect)
mail_folders = TreeElement.get_flattened_nodes(@folder_tree)
mail_folder_ids = mail_folders.collect{|rec| rec.id.to_s}
@unread_emails_h = {}
unless mail_folder_ids.nil? or mail_folder_ids.empty?
unread_emails = Email.where("user_id=#{@login_user.id} and status='#{Email::STATUS_UNREAD}' and mail_folder_id in (#{mail_folder_ids.join(',')})").to_a
unread_emails.each do |email|
mail_folder = mail_folders.find{|rec| rec.id == email.mail_folder_id}
unless mail_folder.nil?
@unread_emails_h[mail_folder] ||= 0
@unread_emails_h[mail_folder] += 1
end
end
end
@unread_emails_h = @unread_emails_h.sort_by{|mail_folder, count| mail_folders.index(mail_folder) }
@draft_emails_h = {}
unless mail_folder_ids.nil? or mail_folder_ids.empty?
draft_emails = Email.where("user_id=#{@login_user.id} and status='#{Email::STATUS_DRAFT}' and mail_folder_id in (#{mail_folder_ids.join(',')})").to_a
draft_emails.each do |email|
mail_folder = mail_folders.find{|rec| rec.id == email.mail_folder_id}
unless mail_folder.nil?
@draft_emails_h[mail_folder] ||= 0
@draft_emails_h[mail_folder] += 1
end
end
end
@draft_emails_h = @draft_emails_h.sort_by{|mail_folder, count| mail_folders.index(mail_folder) }
@folder_obj_cache ||= MailFolder.build_cache(mail_folders)
render(:layout => (!request.xhr?))
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def closed?
!@server || @server.closed?
end | 1 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | safe |
def get_crm_mon_dom(session)
begin
stdout, _, retval = run_cmd(
session, CRM_MON, '--one-shot', '-r', '--as-xml'
)
if retval == 0
return REXML::Document.new(stdout.join("\n"))
end
rescue
$logger.error 'Failed to parse crm_mon.'
end
return nil
end | 0 | Ruby | CWE-384 | Session Fixation | Authenticating a user, or otherwise establishing a new user session, without invalidating any existing session identifier gives an attacker the opportunity to steal authenticated sessions. | https://cwe.mitre.org/data/definitions/384.html | vulnerable |
it "should accept #{name.inspect}" do
csr = Puppet::SSL::CertificateRequest.new(name)
csr.generate(@signing_key)
@ca.check_internal_signing_policies(name, csr, false)
end | 1 | Ruby | CWE-264 | Permissions, Privileges, and Access Controls | Weaknesses in this category are related to the management of permissions, privileges, and other security features that are used to perform access control. | https://cwe.mitre.org/data/definitions/264.html | safe |
def set_auth_groups
Log.add_info(request, params.inspect)
@folder = Folder.find(params[:id])
if Folder.check_user_auth(@folder.id, @login_user, 'w', true)
read_groups = []
write_groups = []
groups_auth = params[:groups_auth]
unless groups_auth.nil?
groups_auth.each do |auth_param|
user_id = auth_param.split(':').first
auths = auth_param.split(':').last.split('+')
if auths.include?('r')
read_groups << user_id
end
if auths.include?('w')
write_groups << user_id
end
end
end
@folder.set_read_groups read_groups
@folder.set_write_groups write_groups
@folder.save
flash[:notice] = t('msg.register_success')
else
flash[:notice] = 'ERROR:' + t('folder.need_auth_to_modify')
end
@groups = Group.where(nil).to_a
render(:partial => 'ajax_auth_groups', :layout => false)
rescue => evar
Log.add_error(request, evar)
render(:partial => 'ajax_auth_groups', :layout => false)
end | 0 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | vulnerable |
def extract_tar_gz io, destination_dir, pattern = "*" # :nodoc:
open_tar_gz io do |tar|
tar.each do |entry|
next unless File.fnmatch pattern, entry.full_name, File::FNM_DOTMATCH
destination = install_location entry.full_name, destination_dir
FileUtils.rm_rf destination
mkdir_options = {}
mkdir_options[:mode] = entry.header.mode if entry.directory?
mkdir =
if entry.directory? then
destination
else
File.dirname destination
end
FileUtils.mkdir_p mkdir, mkdir_options
File.open destination, 'wb' do |out|
out.write entry.read
FileUtils.chmod entry.header.mode, destination
end if entry.file?
File.symlink(entry.header.linkname, destination) if entry.symlink?
verbose destination
end
end
end | 0 | Ruby | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The software uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the software does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
def with_node
if consistency == :eventual
cluster.with_secondary do |node|
yield node
end
else
cluster.with_primary do |node|
yield node
end
end
end | 1 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | safe |
it 'returns success' do
get "/session/email-login/#{email_token.token}"
expect(response).to redirect_to("/")
end | 0 | Ruby | CWE-287 | Improper Authentication | When an actor claims to have a given identity, the software does not prove or insufficiently proves that the claim is correct. | https://cwe.mitre.org/data/definitions/287.html | vulnerable |
def delete_default_break
Log.add_info(request, params.inspect)
return unless request.post?
unless params[:org_start].nil?
org_start = UtilDateTime.parse(params[:org_start]).to_time
yaml = ApplicationHelper.get_config_yaml
unless yaml[:timecard].nil? or yaml[:timecard]['default_breaks'].nil?
yaml[:timecard]['default_breaks'].each do |span|
if span.first == org_start
yaml[:timecard]['default_breaks'].delete(span)
ApplicationHelper.save_config_yaml(yaml)
break
end
end
end
end
@yaml_timecard = yaml[:timecard]
@yaml_timecard = Hash.new if @yaml_timecard.nil?
render(:partial => 'ajax_config_break', :layout => false)
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def group
Log.add_info(request, params.inspect)
date_s = params[:date]
if date_s.blank?
@date = Date.today
else
@date = Date.parse(date_s)
end
@group_id = params[:id]
SqlHelper.validate_token([@group_id, params[:id]])
group_users = Group.get_users(params[:id])
@user_schedule_hash = {}
unless group_users.nil?
@holidays = Schedule.get_holidays
group_users.each do |user|
@user_schedule_hash[user.id.to_s] = Schedule.get_somebody_week(@login_user, user.id, @date, @holidays)
end
end
params[:display] = params[:action] + '_' + params[:id]
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
it "returns a new Query" do
Moped::Query.should_receive(:new).
with(collection, selector).and_return(query)
collection.find(selector).should eq query
end | 0 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | vulnerable |
it "stores the selector" do
query.selector.should eq selector
end | 0 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | vulnerable |
it "doesn't recognize #index" do
{ :get => "/users" }.should_not be_routable
end | 1 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | safe |
def set_maintenance_project(project)
check_write_access!
if project.class == Project
self.maintenance_project_id = project.id
self.save!
return true
elsif project.class == String
prj = Project.find_by_name(project)
if prj
self.maintenance_project_id = prj.id
self.save!
return true
end
end
return false
end | 1 | Ruby | CWE-275 | Permission Issues | Weaknesses in this category are related to improper assignment or handling of permissions. | https://cwe.mitre.org/data/definitions/275.html | safe |
it "doesn't try to set flags" do
session.stub(socket_for: socket)
expect { session.query(query) }.not_to raise_exception
end | 0 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | vulnerable |
def self.trim(user_id, mail_account_id, max)
SqlHelper.validate_token([user_id, mail_account_id])
begin
count = Email.where("mail_account_id=#{mail_account_id}").count
if count > max
#logger.fatal("[INFO] Email.trim(user_id:#{user_id}, mail_account_id:#{mail_account_id}, max:#{max})")
over_num = count - max
emails = []
# First, empty Trashbox
user = User.find(user_id)
trashbox = MailFolder.get_for(user, mail_account_id, MailFolder::XTYPE_TRASH)
trash_nodes = [trashbox.id.to_s]
trash_nodes += MailFolder.get_childs(trash_nodes.first, true, false)
con = "mail_folder_id in (#{trash_nodes.join(',')})"
emails = Email.where(con).order('updated_at ASC').limit(over_num).to_a
# Now, remove others
if emails.length < over_num
over_num -= emails.length
emails += Email.where("mail_account_id=#{mail_account_id}").order('updated_at ASC').limit(over_num).to_a
end
emails.each do |email|
email.destroy
end
end
rescue
end
end | 0 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | vulnerable |
def test_destroy
auth_source_ldap = AuthSourceLdap.first
User.where(:auth_source_id => auth_source_ldap.id).update_all(:auth_source_id => nil)
delete :destroy, {:id => auth_source_ldap}, set_session_user
assert_redirected_to auth_source_ldaps_url
assert !AuthSourceLdap.exists?(auth_source_ldap.id)
end | 0 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | vulnerable |
def from_string(string)
raise Errors::InvalidObjectId.new(string) unless legal?(string)
data = ""
12.times { |i| data << string[i*2, 2].to_i(16) }
from_data data
end | 1 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | safe |
def get_folders_order
Log.add_info(request, params.inspect)
@folder_id = params[:id]
@group_id = params[:group_id]
SqlHelper.validate_token([@folder_id, @group_id])
if @folder_id != '0'
@folder = Folder.find(@folder_id)
end
@folders = Folder.get_childs_for(@login_user, @folder_id, false, nil, true)
if @folder_id == '0'
delete_ary = FoldersHelper.get_except_top_for_admin(@folders, @group_id)
@folders -= delete_ary
end
session[:folder_id] = @folder_id
render(:partial => 'ajax_folders_order', :layout => false)
rescue => evar
Log.add_error(request, evar)
render(:partial => 'ajax_folders_order', :layout => false)
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def delete_attachment
Log.add_info(request, '') # Not to show passwords.
return unless request.post?
target_user = nil
user_id = params[:user_id]
zeptair_id = params[:zeptair_id]
attachment_id = params[:attachment_id]
SqlHelper.validate_token([user_id, zeptair_id, attachment_id])
unless user_id.blank?
if @login_user.admin?(User::AUTH_ZEPTAIR) or @login_user.id.to_s == user_id.to_s
target_user = User.find(user_id)
end
end
unless zeptair_id.blank?
target_user = User.where("zeptair_id=#{zeptair_id.to_i}").first
unless @login_user.admin?(User::AUTH_ZEPTAIR) or @login_user.id == target_user.id
target_user = nil
end
end
if target_user.nil?
if attachment_id.blank?
query
unless @post_items.nil?
@post_items.each do |post_item|
post_item.attachments_without_content.each do |attach|
attach.destroy
end
post_item.update_attribute(:updated_at, Time.now)
end
end
else
attach = Attachment.find(attachment_id)
item = Item.find(attach.item_id)
if !@login_user.admin?(User::AUTH_ZEPTAIR) and item.user_id != @login_user.id
raise t('msg.need_to_be_owner')
end
if item.xtype != Item::XTYPE_ZEPTAIR_POST
raise t('msg.system_error')
end
attach.destroy
item.update_attribute(:updated_at, Time.now)
end
else
post_item = ZeptairPostHelper.get_item_for(target_user)
post_item.attachments_without_content.each do |attach|
attach.destroy
end
post_item.update_attribute(:updated_at, Time.now)
end
render(:text => t('msg.delete_success'))
rescue => evar
Log.add_error(request, evar)
render(:text => 'ERROR:' + t('msg.system_error'))
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
it "requires an account with mail" do
as_admin do
@user = FactoryGirl.create(:user)
end
get :index, {}, set_session_user.merge(:user => @user.id)
assert_response :redirect
assert_redirected_to edit_user_path(@user)
assert_equal "An email address is required, please update your account details", flash[:error]
end | 1 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | safe |
def add_comment
Log.add_info(request, params.inspect)
return unless request.post?
unless params[:comment][:file].nil?
attach_params = { :file => params[:comment][:file] }
params[:comment].delete(:file)
end
@comment = Comment.new(params.require(:comment).permit(Comment::PERMIT_BASE))
@comment.save!
@item = @comment.item
unless attach_params.nil? or attach_params[:file].size <= 0
@comment.attachments << Attachment.create(attach_params, @comment, 0)
end
# Sends Mail to the owner of the item.
# user = User.find(@item.user_id)
# NoticeMailer.comment(user, ApplicationHelper.root_url(request)).deliver unless user.nil?
case @item.xtype
when Item::XTYPE_WORKFLOW
@workflow = @item.workflow
if @workflow.update_status and @workflow.decided?
@workflow.distribute_cc
end
@orders = @workflow.get_orders
render(:partial => 'ajax_workflow', :layout => false)
when Item::XTYPE_PROJECT
if @comment.xtype == Comment::XTYPE_APPLY
flash[:notice] = t('msg.done_success')
render(:partial => 'ajax_team_cancel', :layout => false)
else
render(:partial => 'ajax_comments', :layout => false)
end
else
render(:partial => 'ajax_comments', :layout => false)
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def test_verify_security_policy_checksum_missing
skip 'openssl is missing' unless defined?(OpenSSL::SSL)
@spec.cert_chain = [PUBLIC_CERT.to_pem]
@spec.signing_key = PRIVATE_KEY
build = Gem::Package.new @gem
build.spec = @spec
build.setup_signer
FileUtils.mkdir 'lib'
FileUtils.touch 'lib/code.rb'
File.open @gem, 'wb' do |gem_io|
Gem::Package::TarWriter.new gem_io do |gem|
build.add_metadata gem
build.add_contents gem
# write bogus data.tar.gz to foil signature
bogus_data = Gem.gzip 'hello'
fake_signer = Class.new do
def digest_name; 'SHA512'; end
def digest_algorithm; Digest(:SHA512); end
def key; 'key'; end
def sign(*); 'fake_sig'; end
end
gem.add_file_signed 'data2.tar.gz', 0444, fake_signer.new do |io|
io.write bogus_data
end
# pre rubygems 2.0 gems do not add checksums
end
end
Gem::Security.trust_dir.trust_cert PUBLIC_CERT
package = Gem::Package.new @gem
package.security_policy = Gem::Security::HighSecurity
e = assert_raises Gem::Security::Exception do
package.verify
end
assert_equal 'invalid signature', e.message
refute package.instance_variable_get(:@spec), '@spec must not be loaded'
assert_empty package.instance_variable_get(:@files), '@files must empty'
end | 1 | Ruby | CWE-347 | Improper Verification of Cryptographic Signature | The software does not verify, or incorrectly verifies, the cryptographic signature for data. | https://cwe.mitre.org/data/definitions/347.html | safe |
def create_info_block(options)
return nil unless options
assignments = options.map { |k, v| "img.#{k} = #{v}" }
code = "lambda { |img| " + assignments.join(";") + "}"
eval code
end | 0 | Ruby | CWE-94 | Improper Control of Generation of Code ('Code Injection') | The software constructs all or part of a code segment using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the syntax or behavior of the intended code segment. | https://cwe.mitre.org/data/definitions/94.html | vulnerable |
def self.get_from_name(user_name)
SqlHelper.validate_token([user_name])
begin
user = User.where("name='#{user_name}'").first
rescue => evar
Log.add_error(nil, evar)
end
return user
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
it "does not re-sync the cluster" do
cluster.should_receive(:sync).never
cluster.socket_for :write
end | 0 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | vulnerable |
def run_auth_requests(session, nodes_to_send, nodes_to_auth, username, password, force=false, local=true)
data = {}
nodes_to_auth.each_with_index { |node, index|
data["node-#{index}"] = node
}
data['username'] = username
data['password'] = password
data['bidirectional'] = 1 if not local
data['force'] = 1 if force
auth_responses = {}
threads = []
nodes_to_send.each { |node|
threads << Thread.new {
code, response = send_request(session, node, 'auth', true, data)
if 200 == code
token = response.strip
if '' == token
auth_responses[node] = {'status' => 'bad_password'}
else
auth_responses[node] = {'status' => 'ok', 'token' => token}
end
else
auth_responses[node] = {'status' => 'noresponse'}
end
}
}
threads.each { |t| t.join }
return auth_responses
end | 0 | Ruby | CWE-384 | Session Fixation | Authenticating a user, or otherwise establishing a new user session, without invalidating any existing session identifier gives an attacker the opportunity to steal authenticated sessions. | https://cwe.mitre.org/data/definitions/384.html | vulnerable |
it "sets the generation time" do
time = Time.at((Time.now.utc - 64800).to_i).utc
Moped::BSON::ObjectId.new(nil, time).generation_time.should == time
end | 0 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | vulnerable |
def self.get_childs(klass, node_id, recursive, ret_obj)
SqlHelper.validate_token([node_id])
array = []
if recursive
tree = klass.get_tree(Hash.new, nil, node_id)
return array if tree.nil?
tree.each do |parent_id, childs|
if ret_obj
array |= childs
else
childs.each do |node|
node_id = node.id.to_s
array << node_id unless array.include?(node_id)
end
end
end
else
nodes = klass.where("parent_id=#{node_id}").order('xorder ASC, id ASC').to_a
if ret_obj
array = nodes
else
nodes.each do |node|
array << node.id.to_s
end
end
end
return array
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def test_jail_classes_should_have_limited_methods
expected = ["new", "methods", "name", "inherited", "method_added", "inspect",
"allow", "allowed?", "allowed_methods", "init_allowed_methods",
"<", # < needed in Rails Object#subclasses_of
"ancestors", "==" # ancestors and == needed in Rails::Generator::Spec#lookup_class
]
objects.each do |object|
assert_equal expected.sort, reject_pretty_methods(object.to_jail.class.methods.map(&:to_s).sort)
end
end | 0 | Ruby | CWE-264 | Permissions, Privileges, and Access Controls | Weaknesses in this category are related to the management of permissions, privileges, and other security features that are used to perform access control. | https://cwe.mitre.org/data/definitions/264.html | vulnerable |
def first
session.simple_query(operation)
end | 0 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | vulnerable |
it "should pass the next serial as the serial number" do
Puppet::SSL::CertificateFactory.expects(:build).with do |*args|
args[3] == @serial
end.returns "my real cert"
@ca.sign(@name, :ca, @request)
end | 0 | Ruby | CWE-264 | Permissions, Privileges, and Access Controls | Weaknesses in this category are related to the management of permissions, privileges, and other security features that are used to perform access control. | https://cwe.mitre.org/data/definitions/264.html | vulnerable |
def destroy_header_menu
Log.add_info(request, params.inspect)
return unless request.post?
@yaml = ApplicationHelper.get_config_yaml
unless params[:org_name].nil? or @yaml[:general]['header_menus'].nil?
@yaml[:general]['header_menus'].each do |header_menu|
if header_menu[0] == params[:org_name]
@yaml[:general]['header_menus'].delete(header_menu)
ApplicationHelper.save_config_yaml(@yaml)
break
end
end
end
render(:partial => 'ajax_header_menu', :layout => false)
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def key; 'key'; end | 1 | Ruby | CWE-347 | Improper Verification of Cryptographic Signature | The software does not verify, or incorrectly verifies, the cryptographic signature for data. | https://cwe.mitre.org/data/definitions/347.html | safe |
it "doesn't recognize #index" do
{ :get => "/users" }.should_not be_routable
end | 1 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | safe |
it "raises an OperationFailure exception" do
session.stub(socket_for: socket)
socket.stub(execute: reply)
expect {
session.execute(operation)
}.to raise_exception(Moped::Errors::OperationFailure)
end | 0 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | vulnerable |
def render_step(the_step, options = {})
if the_step.nil? || the_step.to_s == Wicked::FINISH_STEP
redirect_to_finish_wizard options
else
render the_step, options
end
end | 0 | Ruby | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The software uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the software does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
def load
consistency = session.consistency
@options[:flags] |= [:slave_ok] if consistency == :eventual
reply, @node = session.context.with_node do |node|
[node.query(@database, @collection, @selector, @options), node]
end
@limit -= reply.count if limited?
@cursor_id = reply.cursor_id
reply.documents
end | 1 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | safe |
def secondary?
@secondary
end | 1 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | safe |
it "should fail when a protocol other than :puppet or :file is used" do
@request.stubs(:protocol).returns "http"
proc { @object.select(@request) }.should raise_error(ArgumentError)
end | 1 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | safe |
def deliver!(mail)
envelope_from = mail.return_path || mail.sender || mail.from_addrs.first
return_path = "-f " + '"' + envelope_from.escape_for_shell + '"' if envelope_from
arguments = [settings[:arguments], return_path].compact.join(" ")
self.class.call(settings[:location], arguments, mail.destinations.collect(&:shellescape).join(" "), mail)
end | 1 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | safe |
def test_index_should_show_visible_custom_fields_only
Issue.destroy_all
field_attributes = {:field_format => 'string', :is_for_all => true, :is_filter => true, :trackers => Tracker.all}
@fields = []
@fields << (@field1 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 1', :visible => true)))
@fields << (@field2 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 2', :visible => false, :role_ids => [1, 2])))
@fields << (@field3 = IssueCustomField.create!(field_attributes.merge(:name => 'Field 3', :visible => false, :role_ids => [1, 3])))
@issue = Issue.generate!(
:author_id => 1,
:project_id => 1,
:tracker_id => 1,
:custom_field_values => {@field1.id => 'Value0', @field2.id => 'Value1', @field3.id => 'Value2'}
)
@issue.init_journal(User.find(1))
@issue.update_attribute :custom_field_values, {@field1.id => 'NewValue0', @field2.id => 'NewValue1', @field3.id => 'NewValue2'}
user_with_role_on_other_project = User.generate!
User.add_to_project(user_with_role_on_other_project, Project.find(2), Role.find(3))
users_to_test = {
User.find(1) => [@field1, @field2, @field3],
User.find(3) => [@field1, @field2],
user_with_role_on_other_project => [@field1], # should see field1 only on Project 1
User.generate! => [@field1],
User.anonymous => [@field1]
}
users_to_test.each do |user, visible_fields|
get :index, :format => 'atom', :key => user.rss_key
@fields.each_with_index do |field, i|
if visible_fields.include?(field)
assert_select "content[type=html]", { :text => /NewValue#{i}/, :count => 1 }, "User #{user.id} was not able to view #{field.name} in API"
else
assert_select "content[type=html]", { :text => /NewValue#{i}/, :count => 0 }, "User #{user.id} was able to view #{field.name} in API"
end
end
end
end | 1 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | safe |
def process
# We don't want any tracking back in the fs. Unlikely, but there
# you go.
client = self.host.gsub("..",".")
dir = File.join(Puppet[:reportdir], client)
if ! FileTest.exists?(dir)
FileUtils.mkdir_p(dir)
FileUtils.chmod_R(0750, dir)
end
# Now store the report.
now = Time.now.gmtime
name = %w{year month day hour min}.collect do |method|
# Make sure we're at least two digits everywhere
"%02d" % now.send(method).to_s
end.join("") + ".yaml"
file = File.join(dir, name)
f = Tempfile.new(name, dir)
begin
begin
f.chmod(0640)
f.print to_yaml
ensure
f.close
end
FileUtils.mv(f.path, file)
rescue => detail
puts detail.backtrace if Puppet[:trace]
Puppet.warning "Could not write report for #{client} at #{file}: #{detail}"
end
# Only testing cares about the return value
file
end | 0 | Ruby | CWE-22 | Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') | The software uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the software does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory. | https://cwe.mitre.org/data/definitions/22.html | vulnerable |
def self.count_completed_users(item_id)
SqlHelper.validate_token([item_id])
ack_msg = ZeptairDistHelper.completed_ack_message(item_id)
return Comment.where("(item_id=#{item_id.to_i}) and (xtype='#{Comment::XTYPE_DIST_ACK}') and (message='#{ack_msg}')").count
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def allowed_for_local_cluster(session, action)
pcs_config = PCSConfig.new(Cfgsync::PcsdSettings.from_file('{}').text())
return pcs_config.permissions_local.allows?(
session[:username], session[:usergroups], action
)
end | 0 | Ruby | CWE-384 | Session Fixation | Authenticating a user, or otherwise establishing a new user session, without invalidating any existing session identifier gives an attacker the opportunity to steal authenticated sessions. | https://cwe.mitre.org/data/definitions/384.html | vulnerable |
def self.get_for(user, mail_account_id, xtype)
return nil if user.nil? or mail_account_id.blank?
if user.kind_of?(User)
user_id = user.id
else
user_id = user.to_s
end
SqlHelper.validate_token([user_id, mail_account_id, xtype])
con = []
con << "(user_id=#{user_id})"
con << "(mail_account_id=#{mail_account_id})"
con << "(xtype='#{xtype}')"
return MailFolder.where(con.join(' and ')).first
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def self.load_yaml
return if @yaml_loaded
return unless defined?(gem)
test_syck = ENV['TEST_SYCK']
# Only Ruby 1.8 and 1.9 have syck
test_syck = false unless /^1\./ =~ RUBY_VERSION
unless test_syck
begin
gem 'psych', '>= 1.2.1'
rescue Gem::LoadError
# It's OK if the user does not have the psych gem installed. We will
# attempt to require the stdlib version
end
begin
# Try requiring the gem version *or* stdlib version of psych.
require 'psych'
rescue ::LoadError
# If we can't load psych, thats fine, go on.
else
# If 'yaml' has already been required, then we have to
# be sure to switch it over to the newly loaded psych.
if defined?(YAML::ENGINE) && YAML::ENGINE.yamler != "psych"
YAML::ENGINE.yamler = "psych"
end
require 'rubygems/psych_additions'
require 'rubygems/psych_tree'
end
end
require 'yaml'
# If we're supposed to be using syck, then we may have to force
# activate it via the YAML::ENGINE API.
if test_syck and defined?(YAML::ENGINE)
YAML::ENGINE.yamler = "syck" unless YAML::ENGINE.syck?
end
# Now that we're sure some kind of yaml library is loaded, pull
# in our hack to deal with Syck's DefaultKey ugliness.
require 'rubygems/syck_hack'
@yaml_loaded = true
end | 0 | Ruby | CWE-502 | Deserialization of Untrusted Data | The application deserializes untrusted data without sufficiently verifying that the resulting data will be valid. | https://cwe.mitre.org/data/definitions/502.html | vulnerable |
def self.get_for(user_id, fiscal_year=nil)
SqlHelper.validate_token([user_id, fiscal_year])
begin
con = []
con << "(user_id=#{user_id})"
if fiscal_year.nil?
return PaidHoliday.where(con).order('year ASC').to_a
else
con << "(year=#{fiscal_year})"
return PaidHoliday.where(con.join(' and ')).first
end
rescue
end
return nil
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def new
if params[:action] == 'new'
Log.add_info(request, params.inspect)
end
return unless request.post?
render(:action => 'edit', :layout => (!request.xhr?))
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
it "connects and yields a secondary node" do
replica_set.with_secondary do |node|
@secondaries.map(&:address).should include node.address
end
end | 1 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | safe |
def check_owner
return if params[:id].blank? or @login_user.nil?
begin
owner_id = Location.find(params[:id]).user_id
rescue
owner_id = -1
end
if !@login_user.admin?(User::AUTH_LOCATION) and owner_id != @login_user.id
Log.add_check(request, '[check_owner]'+request.to_s)
flash[:notice] = t('msg.need_to_be_owner')
redirect_to(:controller => 'desktop', :action => 'show')
end
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def setup_user
@request.session[:user] = users(:one).id
users(:one).roles = [Role.default, Role.find_by_name('Viewer')]
end | 0 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | vulnerable |
def initialize(session, query_operation)
@session = session
@query_op = query_operation.dup
@get_more_op = Protocol::GetMore.new(
@query_op.database,
@query_op.collection,
0,
@query_op.limit
)
@kill_cursor_op = Protocol::KillCursors.new([0])
end | 0 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | vulnerable |
def require_smart_proxy_or_login(features = nil)
features = features.call if features.respond_to?(:call)
allowed_smart_proxies = features.blank? ? SmartProxy.all : SmartProxy.with_features(*features)
if !Setting[:restrict_registered_smart_proxies] || auth_smart_proxy(allowed_smart_proxies, Setting[:require_ssl_smart_proxies])
set_admin_user
return true
end
require_login
unless User.current
render_error 'access_denied', :status => :forbidden unless performed? && api_request?
return false
end
authorize
end | 0 | Ruby | CWE-200 | Exposure of Sensitive Information to an Unauthorized Actor | The product exposes sensitive information to an actor that is not explicitly authorized to have access to that information. | https://cwe.mitre.org/data/definitions/200.html | vulnerable |
def executing?(name)
!stack(name).empty?
end | 1 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | safe |
def self.get_my_folder(user_id)
SqlHelper.validate_token([user_id])
return Folder.where("(owner_id=#{user_id}) and (xtype='#{Folder::XTYPE_USER}')").first
end | 1 | Ruby | CWE-89 | Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') | The software constructs all or part of an SQL command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended SQL command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/89.html | safe |
def include_allowed?(target, reader)
doc = reader.document
return false if doc.safe >= ::Asciidoctor::SafeMode::SECURE
return false if doc.attributes.fetch('max-include-depth', 64).to_i < 1
return false if target_uri?(target) && !doc.attributes.key?('allow-uri-read')
true
end | 0 | Ruby | CWE-78 | Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection') | The software constructs all or part of an OS command using externally-influenced input from an upstream component, but it does not neutralize or incorrectly neutralizes special elements that could modify the intended OS command when it is sent to a downstream component. | https://cwe.mitre.org/data/definitions/78.html | vulnerable |
it "updates to a mongo advanced selector" do
stats = Support::Stats.collect do
users.find(scope: scope).sort(_id: 1).explain
end
operation = stats[node_for_reads].grep(Moped::Protocol::Query).last
operation.selector.should eq(
"$query" => { scope: scope },
"$explain" => true,
"$orderby" => { _id: 1 }
)
end | 1 | Ruby | CWE-400 | Uncontrolled Resource Consumption | The software does not properly control the allocation and maintenance of a limited resource, thereby enabling an actor to influence the amount of resources consumed, eventually leading to the exhaustion of available resources. | https://cwe.mitre.org/data/definitions/400.html | safe |
it "sets the :database option" do
session.use :admin
session.options[:database].should eq(:admin)
end | 0 | Ruby | CWE-20 | Improper Input Validation | The product receives input or data, but it does
not validate or incorrectly validates that the input has the
properties that are required to process the data safely and
correctly. | https://cwe.mitre.org/data/definitions/20.html | vulnerable |
Subsets and Splits